Pull request #3312: KERNEL-14012 feat: core/structure文件夹

Merge in VISUAL/fineui from ~DAILER/fineui:es6 to es6

* commit 'c4184571d3c5b808fb3231add275aa356ffdf513':
  KERNEL-14012 feat: core/structure文件夹
  KERNEL-14012 feat: core/structure文件夹
  KERNEL-14012 feat: core/structure文件夹

src/core/index.js

@@ -1,4 +1,3 @@
-
 import * as base from "./2.base";
 import * as ob from "./3.ob";
 import * as widget from "./4.widget";
@@ -7,10 +6,11 @@ import * as action from "./action";
 import * as behavior from "./behavior";
 import * as controllers from "./controller";
 import * as func from "./func";
-import { StyleLoaderManager } from "./loader/loader.style";
+import * as structure from "./structure";
+import {StyleLoaderManager} from "./loader/loader.style";
 import "./h";
-import { ShowListener } from "./listener/listener.show";
-import { shortcut } from "./decorator";
+import {ShowListener} from "./listener/listener.show";
+import {shortcut} from "./decorator";
 
 export * from "./2.base";
 export * from "./3.ob";
@@ -20,6 +20,7 @@ export * from "./action";
 export * from "./behavior";
 export * from "./controller";
 export * from "./func";
+export * from "./structure";
 
 // 有了后删掉
 export const emptyFn = () => { }
@@ -28,7 +29,7 @@ export {
     StyleLoaderManager,
     ShowListener,
     shortcut,
-}
+};
 
 Object.assign(BI, {
     ...base,
@@ -42,4 +43,5 @@ Object.assign(BI, {
     ...func,
     StyleLoaderManager,
     ShowListener,
+    ...structure,
 });

src/core/structure/aspect.js

@@ -1,63 +1,58 @@
-!(function () {
-    function aspect (type) {
-        return function (target, methodName, advice) {
-            var exist = target[methodName],
-                dispatcher;
-
-            if (!exist || exist.target != target) {
-                dispatcher = target[methodName] = function () {
-                    // before methods
-                    var beforeArr = dispatcher.before;
-                    var args = arguments, next;
-                    for (var l = beforeArr.length; l--;) {
-                        next = beforeArr[l].advice.apply(this, args);
-                        if (next === false) {
-                            return false;
-                        }
-                        args = next || args;
-                    }
-                    // target method
-                    var rs = dispatcher.method.apply(this, args);
-                    // after methods
-                    var afterArr = dispatcher.after;
-                    for (var i = 0, ii = afterArr.length; i < ii; i++) {
-                        next = afterArr[i].advice.call(this, rs, args);
-                        if (rs === false) {
-                            return false;
-                        }
-                        args = next || args;
+function _aspect(type) {
+    return function (target, methodName, advice) {
+        let exist = target[methodName],
+            dispatcher;
+
+        if (!exist || exist.target != target) {
+            dispatcher = target[methodName] = function () {
+                // before methods
+                let beforeArr = dispatcher.before;
+                let args = arguments, next;
+                for (let l = beforeArr.length; l--;) {
+                    next = beforeArr[l].advice.apply(this, args);
+                    if (next === false) {
+                        return false;
                     }
-                    return rs;
-                };
-
-                dispatcher.before = [];
-                dispatcher.after = [];
-
-                if (exist) {
-                    dispatcher.method = exist;
+                    args = next || args;
                 }
-                dispatcher.target = target;
-            }
-
-            var aspectArr = (dispatcher || exist)[type];
-            var obj = {
-                advice: advice,
-                _index: aspectArr.length,
-                remove: function () {
-                    aspectArr.splice(this._index, 1);
+                // target method
+                let rs = dispatcher.method.apply(this, args);
+                // after methods
+                let afterArr = dispatcher.after;
+                for (let i = 0, ii = afterArr.length; i < ii; i++) {
+                    next = afterArr[i].advice.call(this, rs, args);
+                    if (rs === false) {
+                        return false;
+                    }
+                    args = next || args;
                 }
+                return rs;
             };
-            aspectArr.push(obj);
 
-            return obj;
+            dispatcher.before = [];
+            dispatcher.after = [];
+
+            if (exist) {
+                dispatcher.method = exist;
+            }
+            dispatcher.target = target;
+        }
+
+        let aspectArr = (dispatcher || exist)[type];
+        let obj = {
+            advice: advice,
+            _index: aspectArr.length,
+            remove: function () {
+                aspectArr.splice(this._index, 1);
+            },
         };
-    }
+        aspectArr.push(obj);
 
-    BI.aspect = {
-        before: aspect("before"),
-        after: aspect("after")
+        return obj;
     };
+}
 
-    return BI.aspect;
-
-})();
+export const aspect = {
+    before: _aspect("before"),
+    after: _aspect("after"),
+};

src/core/structure/base64.js

@@ -1,130 +1,132 @@
+const _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 
-!(function () {
 
-    var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+// private method for UTF-8 encoding
+const _utf8_encode = function (string) {
+    string = string.replace(/\r\n/g, "\n");
+    let utftext = "";
 
+    for (let n = 0; n < string.length; n++) {
 
-    // private method for UTF-8 encoding
-    var _utf8_encode = function (string) {
-        string = string.replace(/\r\n/g, "\n");
-        var utftext = "";
-
-        for (var n = 0; n < string.length; n++) {
-
-            var c = string.charCodeAt(n);
-
-            if (c < 128) {
-                utftext += String.fromCharCode(c);
-            } else if ((c > 127) && (c < 2048)) {
-                utftext += String.fromCharCode((c >> 6) | 192);
-                utftext += String.fromCharCode((c & 63) | 128);
-            } else {
-                utftext += String.fromCharCode((c >> 12) | 224);
-                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
-                utftext += String.fromCharCode((c & 63) | 128);
-            }
+        const c = string.charCodeAt(n);
 
+        if (c < 128) {
+            utftext += String.fromCharCode(c);
+        } else if ((c > 127) && (c < 2048)) {
+            utftext += String.fromCharCode((c >> 6) | 192);
+            utftext += String.fromCharCode((c & 63) | 128);
+        } else {
+            utftext += String.fromCharCode((c >> 12) | 224);
+            utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+            utftext += String.fromCharCode((c & 63) | 128);
         }
 
-        return utftext;
-    };
-
-    // private method for UTF-8 decoding
-    var _utf8_decode = function (utftext) {
-        var string = "";
-        var i = 0;
-        var c = 0, c3 = 0, c2 = 0;
-
-        while (i < utftext.length) {
-
-            c = utftext.charCodeAt(i);
-
-            if (c < 128) {
-                string += String.fromCharCode(c);
-                i++;
-            } else if ((c > 191) && (c < 224)) {
-                c2 = utftext.charCodeAt(i + 1);
-                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
-                i += 2;
-            } else {
-                c2 = utftext.charCodeAt(i + 1);
-                c3 = utftext.charCodeAt(i + 2);
-                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
-                i += 3;
-            }
-
+    }
+
+    return utftext;
+};
+
+// private method for UTF-8 decoding
+const _utf8_decode = function (utftext) {
+    let string = "";
+    let i = 0;
+    let c = 0, c3 = 0, c2 = 0;
+
+    while (i < utftext.length) {
+
+        c = utftext.charCodeAt(i);
+
+        if (c < 128) {
+            string += String.fromCharCode(c);
+            i++;
+        } else if ((c > 191) && (c < 224)) {
+            c2 = utftext.charCodeAt(i + 1);
+            string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+            i += 2;
+        } else {
+            c2 = utftext.charCodeAt(i + 1);
+            c3 = utftext.charCodeAt(i + 2);
+            string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+            i += 3;
         }
-        return string;
-    };
-
-    BI._.extend(BI, {
-
-        encode: function (input) {
-            var output = "";
-            var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
-            var i = 0;
-
-            input = _utf8_encode(input);
 
-            while (i < input.length) {
-
-                chr1 = input.charCodeAt(i++);
-                chr2 = input.charCodeAt(i++);
-                chr3 = input.charCodeAt(i++);
-
-                enc1 = chr1 >> 2;
-                enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
-                enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
-                enc4 = chr3 & 63;
-
-                if (isNaN(chr2)) {
-                    enc3 = enc4 = 64;
-                } else if (isNaN(chr3)) {
-                    enc4 = 64;
-                }
+    }
+    return string;
+};
+
+/**
+ * base64 encode
+ * @param input
+ * @returns {string}
+ */
+export function encode(input) {
+    let output = "";
+    let chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+    let i = 0;
+
+    input = _utf8_encode(input);
+
+    while (i < input.length) {
+
+        chr1 = input.charCodeAt(i++);
+        chr2 = input.charCodeAt(i++);
+        chr3 = input.charCodeAt(i++);
+
+        enc1 = chr1 >> 2;
+        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+        enc4 = chr3 & 63;
+
+        if (isNaN(chr2)) {
+            enc3 = enc4 = 64;
+        } else if (isNaN(chr3)) {
+            enc4 = 64;
+        }
 
-                output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
+        output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
 
-            }
+    }
 
-            return output;
-        },
+    return output;
+}
 
-        // public method for decoding
-        decode: function (input) {
-            var output = "";
-            var chr1, chr2, chr3;
-            var enc1, enc2, enc3, enc4;
-            var i = 0;
+/**
+ * base64 decode
+ * @param input
+ * @returns {string}
+ */
+export function decode(input) {
+    let output = "";
+    let chr1, chr2, chr3;
+    let enc1, enc2, enc3, enc4;
+    let i = 0;
 
-            input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+    input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
 
-            while (i < input.length) {
+    while (i < input.length) {
 
-                enc1 = _keyStr.indexOf(input.charAt(i++));
-                enc2 = _keyStr.indexOf(input.charAt(i++));
-                enc3 = _keyStr.indexOf(input.charAt(i++));
-                enc4 = _keyStr.indexOf(input.charAt(i++));
+        enc1 = _keyStr.indexOf(input.charAt(i++));
+        enc2 = _keyStr.indexOf(input.charAt(i++));
+        enc3 = _keyStr.indexOf(input.charAt(i++));
+        enc4 = _keyStr.indexOf(input.charAt(i++));
 
-                chr1 = (enc1 << 2) | (enc2 >> 4);
-                chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
-                chr3 = ((enc3 & 3) << 6) | enc4;
+        chr1 = (enc1 << 2) | (enc2 >> 4);
+        chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+        chr3 = ((enc3 & 3) << 6) | enc4;
 
-                output = output + String.fromCharCode(chr1);
+        output = output + String.fromCharCode(chr1);
 
-                if (enc3 != 64) {
-                    output = output + String.fromCharCode(chr2);
-                }
-                if (enc4 != 64) {
-                    output = output + String.fromCharCode(chr3);
-                }
+        if (enc3 != 64) {
+            output = output + String.fromCharCode(chr2);
+        }
+        if (enc4 != 64) {
+            output = output + String.fromCharCode(chr3);
+        }
 
-            }
+    }
 
-            output = _utf8_decode(output);
+    output = _utf8_decode(output);
 
-            return output;
+    return output;
 
-        }
-    });
-})();
+}

src/core/structure/cache.js

@@ -1,43 +1,42 @@
-
-BI.Cache = {
+export const Cache = {
     _prefix: "bi",
     setUsername: function (username) {
-        localStorage.setItem(BI.Cache._prefix + ".username", (username + "" || "").toUpperCase());
+        localStorage.setItem(Cache._prefix + ".username", (username + "" || "").toUpperCase());
     },
     getUsername: function () {
-        return localStorage.getItem(BI.Cache._prefix + ".username") || "";
+        return localStorage.getItem(Cache._prefix + ".username") || "";
     },
     _getKeyPrefix: function () {
-        return BI.Cache.getUsername() + "." + BI.Cache._prefix + ".";
+        return Cache.getUsername() + "." + Cache._prefix + ".";
     },
     _generateKey: function (key) {
-        return BI.Cache._getKeyPrefix() + (key || "");
+        return Cache._getKeyPrefix() + (key || "");
     },
     getItem: function (key) {
-        return localStorage.getItem(BI.Cache._generateKey(key));
+        return localStorage.getItem(Cache._generateKey(key));
     },
     setItem: function (key, value) {
-        localStorage.setItem(BI.Cache._generateKey(key), value);
+        localStorage.setItem(Cache._generateKey(key), value);
     },
     removeItem: function (key) {
-        localStorage.removeItem(BI.Cache._generateKey(key));
+        localStorage.removeItem(Cache._generateKey(key));
     },
     clear: function () {
-        for (var i = localStorage.length; i >= 0; i--) {
-            var key = localStorage.key(i);
+        for (let i = localStorage.length; i >= 0; i--) {
+            const key = localStorage.key(i);
             if (key) {
-                if (key.indexOf(BI.Cache._getKeyPrefix()) === 0) {
+                if (key.indexOf(Cache._getKeyPrefix()) === 0) {
                     localStorage.removeItem(key);
                 }
             }
         }
     },
     keys: function () {
-        var result = [];
-        for (var i = localStorage.length; i >= 0; i--) {
-            var key = localStorage.key(i);
+        const result = [];
+        for (let i = localStorage.length; i >= 0; i--) {
+            const key = localStorage.key(i);
             if (key) {
-                var prefix = BI.Cache._getKeyPrefix();
+                const prefix = Cache._getKeyPrefix();
                 if (key.indexOf(prefix) === 0) {
                     result[result.length] = key.substring(prefix.length);
                 }
@@ -47,10 +46,10 @@ BI.Cache = {
     },
 
     addCookie: function (name, value, path, expiresHours) {
-        var cookieString = name + "=" + encodeURI(value);
+        let cookieString = name + "=" + encodeURI(value);
         // 判断是否设置过期时间
         if (expiresHours && expiresHours > 0) {
-            var date = new Date();
+            const date = new Date();
             // expires是标准GMT格式时间，应该使用时间戳作为起始时间
             date.setTime(date.getTime() + expiresHours * 3600 * 1000);
             cookieString = cookieString + "; expires=" + date.toUTCString();
@@ -61,17 +60,19 @@ BI.Cache = {
         document.cookie = cookieString;
     },
     getCookie: function (name) {
-        var arr, reg = new RegExp("(^| )" + name + "=([^;]*)(;|$)");
-        if (arr = document.cookie.match(reg)) {return decodeURI(arr[2]);}
+        let arr, reg = new RegExp("(^| )" + name + "=([^;]*)(;|$)");
+        if (arr = document.cookie.match(reg)) {
+            return decodeURI(arr[2]);
+        }
         return null;
     },
     deleteCookie: function (name, path) {
-        var date = new Date();
+        const date = new Date();
         date.setTime(date.getTime() - 10000);
-        var cookieString = name + "=v; expires=" + date.toUTCString();
+        let cookieString = name + "=v; expires=" + date.toUTCString();
         if (path) {
             cookieString = cookieString + "; path=" + path;
         }
         document.cookie = cookieString;
-    }
+    },
 };

src/core/structure/cellSizeAndPositionManager.js

@@ -1,40 +1,40 @@
-BI.CellSizeAndPositionManager = function (cellCount, cellSizeGetter, estimatedCellSize) {
-    this._cellSizeGetter = cellSizeGetter;
-    this._cellCount = cellCount;
-    this._estimatedCellSize = estimatedCellSize;
-    this._cellSizeAndPositionData = {};
-    this._lastMeasuredIndex = -1;
-};
-
-BI.CellSizeAndPositionManager.prototype = {
-    constructor: BI.CellSizeAndPositionManager,
-    configure: function (cellCount, estimatedCellSize) {
+export class CellSizeAndPositionManager {
+
+    constructor(cellCount, cellSizeGetter, estimatedCellSize) {
+        this._cellSizeGetter = cellSizeGetter;
         this._cellCount = cellCount;
         this._estimatedCellSize = estimatedCellSize;
-    },
+        this._cellSizeAndPositionData = {};
+        this._lastMeasuredIndex = -1;
+    }
 
-    getCellCount: function () {
+    configure(cellCount, estimatedCellSize) {
+        this._cellCount = cellCount;
+        this._estimatedCellSize = estimatedCellSize;
+    }
+
+    getCellCount() {
         return this._cellCount;
-    },
+    }
 
-    getEstimatedCellSize: function () {
+    getEstimatedCellSize() {
         return this._estimatedCellSize;
-    },
+    }
 
-    getLastMeasuredIndex: function () {
+    getLastMeasuredIndex() {
         return this._lastMeasuredIndex;
-    },
+    }
 
-    getSizeAndPositionOfCell: function (index) {
+    getSizeAndPositionOfCell(index) {
         if (index < 0 || index >= this._cellCount) {
             return;
         }
         if (index > this._lastMeasuredIndex) {
-            var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
-            var offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;
+            const lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+            let offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;
 
-            for (var i = this._lastMeasuredIndex + 1; i <= index; i++) {
-                var size = this._cellSizeGetter(i);
+            for (let i = this._lastMeasuredIndex + 1; i <= index; i++) {
+                const size = this._cellSizeGetter(i);
 
                 if (size == null || isNaN(size)) {
                     continue;
@@ -42,7 +42,7 @@ BI.CellSizeAndPositionManager.prototype = {
 
                 this._cellSizeAndPositionData[i] = {
                     offset: offset,
-                    size: size
+                    size: size,
                 };
 
                 offset += size;
@@ -51,28 +51,28 @@ BI.CellSizeAndPositionManager.prototype = {
             this._lastMeasuredIndex = index;
         }
         return this._cellSizeAndPositionData[index];
-    },
+    }
 
-    getSizeAndPositionOfLastMeasuredCell: function () {
+    getSizeAndPositionOfLastMeasuredCell() {
         return this._lastMeasuredIndex >= 0
             ? this._cellSizeAndPositionData[this._lastMeasuredIndex]
             : {
                 offset: 0,
-                size: 0
+                size: 0,
             };
-    },
+    }
 
-    getTotalSize: function () {
-        var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+    getTotalSize() {
+        const lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
         return lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size + (this._cellCount - this._lastMeasuredIndex - 1) * this._estimatedCellSize;
-    },
+    }
 
-    getUpdatedOffsetForIndex: function (align, containerSize, currentOffset, targetIndex) {
-        var datum = this.getSizeAndPositionOfCell(targetIndex);
-        var maxOffset = datum.offset;
-        var minOffset = maxOffset - containerSize + datum.size;
+    getUpdatedOffsetForIndex(align, containerSize, currentOffset, targetIndex) {
+        const datum = this.getSizeAndPositionOfCell(targetIndex);
+        const maxOffset = datum.offset;
+        const minOffset = maxOffset - containerSize + datum.size;
 
-        var idealOffset;
+        let idealOffset;
 
         switch (align) {
             case "start":
@@ -89,25 +89,25 @@ BI.CellSizeAndPositionManager.prototype = {
                 break;
         }
 
-        var totalSize = this.getTotalSize();
+        const totalSize = this.getTotalSize();
 
         return Math.max(0, Math.min(totalSize - containerSize, idealOffset));
-    },
+    }
 
-    getVisibleCellRange: function (containerSize, offset) {
-        var totalSize = this.getTotalSize();
+    getVisibleCellRange(containerSize, offset) {
+        const totalSize = this.getTotalSize();
 
         if (totalSize === 0) {
             return {};
         }
 
-        var maxOffset = offset + containerSize;
-        var start = this._findNearestCell(offset);
+        const maxOffset = offset + containerSize;
+        const start = this._findNearestCell(offset);
 
-        var datum = this.getSizeAndPositionOfCell(start);
+        const datum = this.getSizeAndPositionOfCell(start);
         offset = datum.offset + datum.size;
 
-        var stop = start;
+        let stop = start;
 
         while (offset < maxOffset && stop < this._cellCount - 1) {
             stop++;
@@ -116,17 +116,17 @@ BI.CellSizeAndPositionManager.prototype = {
 
         return {
             start: start,
-            stop: stop
+            stop: stop,
         };
-    },
+    }
 
-    resetCell: function (index) {
+    resetCell(index) {
         this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1);
-    },
+    }
 
-    _binarySearch: function (high, low, offset) {
-        var middle;
-        var currentOffset;
+    _binarySearch(high, low, offset) {
+        let middle;
+        let currentOffset;
 
         while (low <= high) {
             middle = low + Math.floor((high - low) / 2);
@@ -144,10 +144,10 @@ BI.CellSizeAndPositionManager.prototype = {
         if (low > 0) {
             return low - 1;
         }
-    },
+    }
 
-    _exponentialSearch: function (index, offset) {
-        var interval = 1;
+    _exponentialSearch(index, offset) {
+        let interval = 1;
 
         while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) {
             index += interval;
@@ -155,117 +155,115 @@ BI.CellSizeAndPositionManager.prototype = {
         }
 
         return this._binarySearch(Math.min(index, this._cellCount - 1), Math.floor(index / 2), offset);
-    },
+    }
 
-    _findNearestCell: function (offset) {
+    _findNearestCell(offset) {
         if (isNaN(offset)) {
             return;
         }
 
         offset = Math.max(0, offset);
 
-        var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
-        var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);
+        const lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+        const lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);
 
         if (lastMeasuredCellSizeAndPosition.offset >= offset) {
             return this._binarySearch(lastMeasuredIndex, 0, offset);
         }
         return this._exponentialSearch(lastMeasuredIndex, offset);
-        
-    }
-};
 
-BI.ScalingCellSizeAndPositionManager = function (cellCount, cellSizeGetter, estimatedCellSize, maxScrollSize) {
-    this._cellSizeAndPositionManager = new BI.CellSizeAndPositionManager(cellCount, cellSizeGetter, estimatedCellSize);
-    this._maxScrollSize = maxScrollSize || 10000000;
-};
+    }
+}
 
-BI.ScalingCellSizeAndPositionManager.prototype = {
-    constructor: BI.ScalingCellSizeAndPositionManager,
+export class ScalingCellSizeAndPositionManager {
+    constructor(cellCount, cellSizeGetter, estimatedCellSize, maxScrollSize) {
+        this._cellSizeAndPositionManager = new CellSizeAndPositionManager(cellCount, cellSizeGetter, estimatedCellSize);
+        this._maxScrollSize = maxScrollSize || 10000000;
+    }
 
-    configure: function () {
+    configure() {
         this._cellSizeAndPositionManager.configure.apply(this._cellSizeAndPositionManager, arguments);
-    },
+    }
 
-    getCellCount: function () {
+    getCellCount() {
         return this._cellSizeAndPositionManager.getCellCount();
-    },
+    }
 
-    getEstimatedCellSize: function () {
+    getEstimatedCellSize() {
         return this._cellSizeAndPositionManager.getEstimatedCellSize();
-    },
+    }
 
-    getLastMeasuredIndex: function () {
+    getLastMeasuredIndex() {
         return this._cellSizeAndPositionManager.getLastMeasuredIndex();
-    },
+    }
 
-    getOffsetAdjustment: function (containerSize, offset) {
-        var totalSize = this._cellSizeAndPositionManager.getTotalSize();
-        var safeTotalSize = this.getTotalSize();
-        var offsetPercentage = this._getOffsetPercentage(containerSize, offset, safeTotalSize);
+    getOffsetAdjustment(containerSize, offset) {
+        const totalSize = this._cellSizeAndPositionManager.getTotalSize();
+        const safeTotalSize = this.getTotalSize();
+        const offsetPercentage = this._getOffsetPercentage(containerSize, offset, safeTotalSize);
 
         return Math.round(offsetPercentage * (safeTotalSize - totalSize));
-    },
+    }
 
-    getSizeAndPositionOfCell: function (index) {
+    getSizeAndPositionOfCell(index) {
         return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);
-    },
+    }
 
-    getSizeAndPositionOfLastMeasuredCell: function () {
+    getSizeAndPositionOfLastMeasuredCell() {
         return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell();
-    },
+    }
 
-    getTotalSize: function () {
+    getTotalSize() {
         return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize());
-    },
+    }
 
-    getUpdatedOffsetForIndex: function (align, containerSize, currentOffset, targetIndex) {
+    getUpdatedOffsetForIndex(align, containerSize, currentOffset, targetIndex) {
         currentOffset = this._safeOffsetToOffset(containerSize, currentOffset);
 
-        var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex(align, containerSize, currentOffset, targetIndex);
+        const offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex(align, containerSize, currentOffset, targetIndex);
 
         return this._offsetToSafeOffset(containerSize, offset);
-    },
+    }
 
-    getVisibleCellRange: function (containerSize, offset) {
+    getVisibleCellRange(containerSize, offset) {
         offset = this._safeOffsetToOffset(containerSize, offset);
 
         return this._cellSizeAndPositionManager.getVisibleCellRange(containerSize, offset);
-    },
+    }
 
-    resetCell: function (index) {
+    resetCell(index) {
         this._cellSizeAndPositionManager.resetCell(index);
-    },
+    }
 
-    _getOffsetPercentage: function (containerSize, offset, totalSize) {
+    _getOffsetPercentage(containerSize, offset, totalSize) {
         return totalSize <= containerSize
             ? 0
             : offset / (totalSize - containerSize);
-    },
+    }
 
-    _offsetToSafeOffset: function (containerSize, offset) {
-        var totalSize = this._cellSizeAndPositionManager.getTotalSize();
-        var safeTotalSize = this.getTotalSize();
+    _offsetToSafeOffset(containerSize, offset) {
+        const totalSize = this._cellSizeAndPositionManager.getTotalSize();
+        const safeTotalSize = this.getTotalSize();
 
         if (totalSize === safeTotalSize) {
             return offset;
         }
-        var offsetPercentage = this._getOffsetPercentage(containerSize, offset, totalSize);
+        const offsetPercentage = this._getOffsetPercentage(containerSize, offset, totalSize);
 
         return Math.round(offsetPercentage * (safeTotalSize - containerSize));
-        
-    },
 
-    _safeOffsetToOffset: function (containerSize, offset) {
-        var totalSize = this._cellSizeAndPositionManager.getTotalSize();
-        var safeTotalSize = this.getTotalSize();
+    }
+
+    _safeOffsetToOffset(containerSize, offset) {
+        const totalSize = this._cellSizeAndPositionManager.getTotalSize();
+        const safeTotalSize = this.getTotalSize();
 
         if (totalSize === safeTotalSize) {
             return offset;
         }
-        var offsetPercentage = this._getOffsetPercentage(containerSize, offset, safeTotalSize);
+        const offsetPercentage = this._getOffsetPercentage(containerSize, offset, safeTotalSize);
 
         return Math.round(offsetPercentage * (totalSize - containerSize));
-        
+
     }
-};
+}

src/core/structure/heap.js

@@ -1,115 +1,111 @@
+function defaultComparator(a, b) {
+    return a < b;
+}
 
-(function () {
-    function defaultComparator (a, b) {
-        return a < b;
-    }
-
-    BI.Heap = function (items, comparator) {
+export class Heap {
+    constructor(items, comparator) {
         this._items = items || [];
         this._size = this._items.length;
         this._comparator = comparator || defaultComparator;
         this._heapify();
-    };
-
-    BI.Heap.prototype = {
-        constructor: BI.Heap,
-        empty: function () {
-            return this._size === 0;
-        },
+    }
 
-        pop: function () {
-            if (this._size === 0) {
-                return;
-            }
+    empty() {
+        return this._size === 0;
+    }
 
-            var elt = this._items[0];
+    pop() {
+        if (this._size === 0) {
+            return;
+        }
 
-            var lastElt = this._items.pop();
-            this._size--;
+        const elt = this._items[0];
 
-            if (this._size > 0) {
-                this._items[0] = lastElt;
-                this._sinkDown(0);
-            }
+        const lastElt = this._items.pop();
+        this._size--;
 
-            return elt;
-        },
+        if (this._size > 0) {
+            this._items[0] = lastElt;
+            this._sinkDown(0);
+        }
 
-        push: function (item) {
-            this._items[this._size++] = item;
-            this._bubbleUp(this._size - 1);
-        },
+        return elt;
+    }
 
-        size: function () {
-            return this._size;
-        },
+    push(item) {
+        this._items[this._size++] = item;
+        this._bubbleUp(this._size - 1);
+    }
 
-        peek: function () {
-            if (this._size === 0) {
-                return;
-            }
+    size() {
+        return this._size;
+    }
 
-            return this._items[0];
-        },
+    peek() {
+        if (this._size === 0) {
+            return;
+        }
 
-        _heapify: function () {
-            for (var index = Math.floor((this._size + 1) / 2); index >= 0; index--) {
-                this._sinkDown(index);
-            }
-        },
+        return this._items[0];
+    }
 
-        _bubbleUp: function (index) {
-            var elt = this._items[index];
-            while (index > 0) {
-                var parentIndex = Math.floor((index + 1) / 2) - 1;
-                var parentElt = this._items[parentIndex];
+    _heapify() {
+        for (let index = Math.floor((this._size + 1) / 2); index >= 0; index--) {
+            this._sinkDown(index);
+        }
+    }
 
-                // if parentElt < elt, stop
-                if (this._comparator(parentElt, elt)) {
-                    return;
-                }
+    _bubbleUp(index) {
+        const elt = this._items[index];
+        while (index > 0) {
+            const parentIndex = Math.floor((index + 1) / 2) - 1;
+            const parentElt = this._items[parentIndex];
 
-                // swap
-                this._items[parentIndex] = elt;
-                this._items[index] = parentElt;
-                index = parentIndex;
+            // if parentElt < elt, stop
+            if (this._comparator(parentElt, elt)) {
+                return;
             }
-        },
 
-        _sinkDown: function (index) {
-            var elt = this._items[index];
+            // swap
+            this._items[parentIndex] = elt;
+            this._items[index] = parentElt;
+            index = parentIndex;
+        }
+    }
 
-            while (true) {
-                var leftChildIndex = 2 * (index + 1) - 1;
-                var rightChildIndex = 2 * (index + 1);
-                var swapIndex = -1;
+    _sinkDown(index) {
+        const elt = this._items[index];
 
-                if (leftChildIndex < this._size) {
-                    var leftChild = this._items[leftChildIndex];
-                    if (this._comparator(leftChild, elt)) {
-                        swapIndex = leftChildIndex;
-                    }
-                }
+        while (true) {
+            const leftChildIndex = 2 * (index + 1) - 1;
+            const rightChildIndex = 2 * (index + 1);
+            let swapIndex = -1;
 
-                if (rightChildIndex < this._size) {
-                    var rightChild = this._items[rightChildIndex];
-                    if (this._comparator(rightChild, elt)) {
-                        if (swapIndex === -1 ||
-                            this._comparator(rightChild, this._items[swapIndex])) {
-                            swapIndex = rightChildIndex;
-                        }
-                    }
+            if (leftChildIndex < this._size) {
+                const leftChild = this._items[leftChildIndex];
+                if (this._comparator(leftChild, elt)) {
+                    swapIndex = leftChildIndex;
                 }
+            }
 
-                // if we don't have a swap, stop
-                if (swapIndex === -1) {
-                    return;
+            if (rightChildIndex < this._size) {
+                const rightChild = this._items[rightChildIndex];
+                if (this._comparator(rightChild, elt)) {
+                    if (swapIndex === -1 ||
+                        this._comparator(rightChild, this._items[swapIndex])) {
+                        swapIndex = rightChildIndex;
+                    }
                 }
+            }
 
-                this._items[index] = this._items[swapIndex];
-                this._items[swapIndex] = elt;
-                index = swapIndex;
+            // if we don't have a swap, stop
+            if (swapIndex === -1) {
+                return;
             }
+
+            this._items[index] = this._items[swapIndex];
+            this._items[swapIndex] = elt;
+            index = swapIndex;
         }
-    };
-})();
+    }
+}

src/core/structure/index.js

@@ -0,0 +1,13 @@
+export * from "./aes";
+export * from "./aspect";
+export * from "./base64";
+export * from "./cache";
+export * from "./cellSizeAndPositionManager";
+export * from "./heap";
+export * from "./linkedHashMap";
+export * from "./lru";
+export * from "./prefixIntervalTree";
+export * from "./queue";
+export * from "./sectionManager";
+export * from "./tree";
+export * from "./vector";

src/core/structure/linkedHashMap.js

@@ -1,72 +1,66 @@
-
-!(function () {
-    BI.LinkHashMap = function () {
+export class LinkHashMap {
+    constructor() {
         this.array = [];
         this.map = {};
-    };
-    BI.LinkHashMap.prototype = {
-        constructor: BI.LinkHashMap,
-        has: function (key) {
-            if (key in this.map) {
-                return true;
-            }
-            return false;
-        },
-
-        add: function (key, value) {
-            if (typeof key === "undefined") {
-                return;
-            }
-            if (key in this.map) {
-                this.map[key] = value;
-            } else {
-                this.array.push(key);
-                this.map[key] = value;
-            }
-        },
+    }
 
-        remove: function (key) {
-            if (key in this.map) {
-                delete this.map[key];
-                for (var i = 0; i < this.array.length; i++) {
-                    if (this.array[i] == key) {
-                        this.array.splice(i, 1);
-                        break;
-                    }
-                }
-            }
-        },
+    has(key) {
+        return key in this.map;
+    }
 
-        size: function () {
-            return this.array.length;
-        },
+    add(key, value) {
+        if (typeof key === "undefined") {
+            return;
+        }
+        if (key in this.map) {
+            this.map[key] = value;
+        } else {
+            this.array.push(key);
+            this.map[key] = value;
+        }
+    }
 
-        each: function (fn, scope) {
-            var scope = scope || window;
-            var fn = fn || null;
-            if (fn == null || typeof (fn) !== "function") {
-                return;
-            }
-            for (var i = 0; i < this.array.length; i++) {
-                var key = this.array[i];
-                var value = this.map[key];
-                var re = fn.call(scope, key, value, i, this.array, this.map);
-                if (re == false) {
+    remove(key) {
+        if (key in this.map) {
+            delete this.map[key];
+            for (let i = 0; i < this.array.length; i++) {
+                if (this.array[i] == key) {
+                    this.array.splice(i, 1);
                     break;
                 }
             }
-        },
+        }
+    }
 
-        get: function (key) {
-            return this.map[key];
-        },
+    size() {
+        return this.array.length;
+    }
 
-        toArray: function () {
-            var array = [];
-            this.each(function (key, value) {
-                array.push(value);
-            });
-            return array;
+    each(fn, scope) {
+        scope = scope || window;
+        fn = fn || null;
+        if (fn == null || typeof (fn) !== "function") {
+            return;
         }
-    };
-})();
+        for (let i = 0; i < this.array.length; i++) {
+            const key = this.array[i];
+            const value = this.map[key];
+            const re = fn.call(scope, key, value, i, this.array, this.map);
+            if (re == false) {
+                break;
+            }
+        }
+    }
+
+    get(key) {
+        return this.map[key];
+    }
+
+    toArray() {
+        const array = [];
+        this.each(function (key, value) {
+            array.push(value);
+        });
+        return array;
+    }
+}

src/core/structure/lru.js

@@ -1,24 +1,21 @@
-
-!(function () {
-    BI.LRU = function (limit) {
+export class LRU {
+    constructor(limit) {
         this.size = 0;
         this.limit = limit;
         this.head = this.tail = undefined;
         this._keymap = {};
-    };
-
-    var p = BI.LRU.prototype;
+    }
 
-    p.put = function (key, value) {
-        var removed;
+    put(key, value) {
+        let removed;
         if (this.size === this.limit) {
             removed = this.shift();
         }
 
-        var entry = this.get(key, true);
+        let entry = this.get(key, true);
         if (!entry) {
             entry = {
-                key: key
+                key: key,
             };
             this._keymap[key] = entry;
             if (this.tail) {
@@ -33,10 +30,10 @@
         entry.value = value;
 
         return removed;
-    };
+    }
 
-    p.shift = function () {
-        var entry = this.head;
+    shift() {
+        const entry = this.head;
         if (entry) {
             this.head = this.head.newer;
             this.head.older = undefined;
@@ -45,11 +42,10 @@
             this.size--;
         }
         return entry;
-    };
-
+    }
 
-    p.get = function (key, returnEntry) {
-        var entry = this._keymap[key];
+    get(key, returnEntry) {
+        const entry = this._keymap[key];
         if (entry === undefined) return;
         if (entry === this.tail) {
             return returnEntry
@@ -78,9 +74,9 @@
         return returnEntry
             ? entry
             : entry.value;
-    };
+    }
 
-    p.has = function (key) {
+    has(key) {
         return this._keymap[key] != null;
-    };
-})();
+    }
+}

src/core/structure/prefixIntervalTree.js

@@ -1,32 +1,32 @@
 // 线段树
-(function () {
-    var parent = function (node) {
-        return Math.floor(node / 2);
-    };
-
-    var Int32Array = _global.Int32Array || function (size) {
-        var xs = [];
-        for (var i = size - 1; i >= 0; --i) {
-            xs[i] = 0;
-        }
-        return xs;
-    };
-
-    var ceilLog2 = function (x) {
-        var y = 1;
-        while (y < x) {
-            y *= 2;
-        }
-        return y;
-    };
-
-    BI.PrefixIntervalTree = function (xs) {
+const parent = function (node) {
+    return Math.floor(node / 2);
+};
+
+const Int32Array = _global.Int32Array || function (size) {
+    const xs = [];
+    for (let i = size - 1; i >= 0; --i) {
+        xs[i] = 0;
+    }
+    return xs;
+};
+
+const ceilLog2 = function (x) {
+    let y = 1;
+    while (y < x) {
+        y *= 2;
+    }
+    return y;
+};
+
+export class PrefixIntervalTree {
+    constructor(xs) {
         this._size = xs.length;
         this._half = ceilLog2(this._size);
         // _heap是一个_size两倍以上的堆
         this._heap = new Int32Array(2 * this._half);
 
-        var i;
+        let i;
         // 初始化 >= _size 的堆空间, 即叶子节点
         for (i = 0; i < this._size; ++i) {
             this._heap[this._half + i] = xs[i];
@@ -35,146 +35,143 @@
         for (i = this._half - 1; i > 0; --i) {
             this._heap[i] = this._heap[2 * i] + this._heap[2 * i + 1];
         }
-    };
-
-    BI.PrefixIntervalTree.prototype = {
-        constructor: BI.PrefixIntervalTree,
-        // 往_half之后的空间set值，需要更新其所有祖先节点的值
-        set: function (index, value) {
-            var node = this._half + index;
-            this._heap[node] = value;
-
-            node = parent(node);
-            for (; node !== 0; node = parent(node)) {
-                this._heap[node] =
-                    this._heap[2 * node] + this._heap[2 * node + 1];
-            }
-        },
+    }
 
-        get: function (index) {
-            var node = this._half + index;
-            return this._heap[node];
-        },
+    static uniform(size, initialValue) {
+        const xs = [];
+        for (let i = size - 1; i >= 0; --i) {
+            xs[i] = initialValue;
+        }
 
-        getSize: function () {
-            return this._size;
-        },
-
-        /**
-         * get(0) + get(1) + ... + get(end - 1).
-         */
-        sumUntil: function (end) {
-            if (end === 0) {
-                return 0;
-            }
+        return new PrefixIntervalTree(xs);
+    }
 
-            var node = this._half + end - 1;
-            var sum = this._heap[node];
-            for (; node !== 1; node = parent(node)) {
-                if (node % 2 === 1) {
-                    sum += this._heap[node - 1];
-                }
-            }
+    static empty(size) {
+        return PrefixIntervalTree.uniform(size, 0);
+    }
 
-            return sum;
-        },
-
-        /**
-         * get(0) + get(1) + ... + get(inclusiveEnd).
-         */
-        sumTo: function (inclusiveEnd) {
-            return this.sumUntil(inclusiveEnd + 1);
-        },
-
-        /**
-         * sum get(begin) + get(begin + 1) + ... + get(end - 1).
-         */
-        sum: function (begin, end) {
-            return this.sumUntil(end) - this.sumUntil(begin);
-        },
-
-        /**
-         * Returns the smallest i such that 0 <= i <= size and sumUntil(i) <= t, or
-         * -1 if no such i exists.
-         */
-        greatestLowerBound: function (t) {
-            if (t < 0) {
-                return -1;
-            }
+    set(index, value) {
+        let node = this._half + index;
+        this._heap[node] = value;
 
-            var node = 1;
-            if (this._heap[node] <= t) {
-                return this._size;
-            }
+        node = parent(node);
+        for (; node !== 0; node = parent(node)) {
+            this._heap[node] =
+                this._heap[2 * node] + this._heap[2 * node + 1];
+        }
+    }
+
+    get(index) {
+        const node = this._half + index;
+        return this._heap[node];
+    }
+
+    getSize() {
+        return this._size;
+    }
+
+    /**
+     * get(0) + get(1) + ... + get(end - 1).
+     */
+    sumUntil(end) {
+        if (end === 0) {
+            return 0;
+        }
 
-            while (node < this._half) {
-                var leftSum = this._heap[2 * node];
-                if (t < leftSum) {
-                    node = 2 * node;
-                } else {
-                    node = 2 * node + 1;
-                    t -= leftSum;
-                }
+        let node = this._half + end - 1;
+        let sum = this._heap[node];
+        for (; node !== 1; node = parent(node)) {
+            if (node % 2 === 1) {
+                sum += this._heap[node - 1];
             }
+        }
 
-            return node - this._half;
-        },
+        return sum;
+    }
+
+    /**
+     * get(0) + get(1) + ... + get(inclusiveEnd).
+     */
+    sumTo(inclusiveEnd) {
+        return this.sumUntil(inclusiveEnd + 1);
+    }
+
+    /**
+     * sum get(begin) + get(begin + 1) + ... + get(end - 1).
+     */
+    sum(begin, end) {
+        return this.sumUntil(end) - this.sumUntil(begin);
+    }
+
+    /**
+     * Returns the smallest i such that 0 <= i <= size and sumUntil(i) <= t, or
+     * -1 if no such i exists.
+     */
+    greatestLowerBound(t) {
+        if (t < 0) {
+            return -1;
+        }
 
-        /**
-         * Returns the smallest i such that 0 <= i <= size and sumUntil(i) < t, or
-         * -1 if no such i exists.
-         */
-        greatestStrictLowerBound: function (t) {
-            if (t <= 0) {
-                return -1;
-            }
+        let node = 1;
+        if (this._heap[node] <= t) {
+            return this._size;
+        }
 
-            var node = 1;
-            if (this._heap[node] < t) {
-                return this._size;
+        while (node < this._half) {
+            const leftSum = this._heap[2 * node];
+            if (t < leftSum) {
+                node = 2 * node;
+            } else {
+                node = 2 * node + 1;
+                t -= leftSum;
             }
+        }
 
-            while (node < this._half) {
-                var leftSum = this._heap[2 * node];
-                if (t <= leftSum) {
-                    node = 2 * node;
-                } else {
-                    node = 2 * node + 1;
-                    t -= leftSum;
-                }
-            }
+        return node - this._half;
+    }
 
-            return node - this._half;
-        },
-
-        /**
-         * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or
-         * size + 1 if no such i exists.
-         */
-        leastUpperBound: function (t) {
-            return this.greatestStrictLowerBound(t) + 1;
-        },
-
-        /**
-         * Returns the smallest i such that 0 <= i <= size and t < sumUntil(i), or
-         * size + 1 if no such i exists.
-         */
-        leastStrictUpperBound: function (t) {
-            return this.greatestLowerBound(t) + 1;
+    /**
+     * Returns the smallest i such that 0 <= i <= size and sumUntil(i) < t, or
+     * -1 if no such i exists.
+     */
+    greatestStrictLowerBound(t) {
+        if (t <= 0) {
+            return -1;
         }
-    };
 
-    BI.PrefixIntervalTree.uniform = function (size, initialValue) {
-        var xs = [];
-        for (var i = size - 1; i >= 0; --i) {
-            xs[i] = initialValue;
+        let node = 1;
+        if (this._heap[node] < t) {
+            return this._size;
         }
 
-        return new BI.PrefixIntervalTree(xs);
-    };
+        while (node < this._half) {
+            const leftSum = this._heap[2 * node];
+            if (t <= leftSum) {
+                node = 2 * node;
+            } else {
+                node = 2 * node + 1;
+                t -= leftSum;
+            }
+        }
+
+        return node - this._half;
+    }
+
+    /**
+     * Returns the smallest i such that 0 <= i <= size and t <= sumUntil(i), or
+     * size + 1 if no such i exists.
+     */
+    leastUpperBound(t) {
+        return this.greatestStrictLowerBound(t) + 1;
+    }
+
+    /**
+     * Returns the smallest i such that 0 <= i <= size and t < sumUntil(i), or
+     * size + 1 if no such i exists.
+     */
+    leastStrictUpperBound(t) {
+        return this.greatestLowerBound(t) + 1;
+    }
 
-    BI.PrefixIntervalTree.empty = function (size) {
-        return BI.PrefixIntervalTree.uniform(size, 0);
-    };
 
-})();
+}

src/core/structure/queue.js

@@ -1,89 +1,86 @@
+import {contains, remove} from "../2.base";
 
-!(function () {
-    BI.Queue = function (capacity) {
+export class Queue {
+    constructor(capacity) {
         this.capacity = capacity;
         this.array = [];
-    };
-    BI.Queue.prototype = {
-        constructor: BI.Queue,
-
-        contains: function (v) {
-            return BI.contains(this.array, v);
-        },
-
-        indexOf: function (v) {
-            return BI.contains(this.array, v);
-        },
-
-        getElementByIndex: function (index) {
-            return this.array[index];
-        },
-
-        push: function (v) {
-            this.array.push(v);
-            if (this.capacity && this.array.length > this.capacity) {
-                this.array.shift();
-            }
-        },
+    }
 
-        pop: function () {
-            this.array.pop();
-        },
+    contains(v) {
+        return contains(this.array, v);
+    }
+
+    indexOf(v) {
+        return contains(this.array, v);
+    }
+
+    getElementByIndex(index) {
+        return this.array[index];
+    }
 
-        shift: function () {
+    push(v) {
+        this.array.push(v);
+        if (this.capacity && this.array.length > this.capacity) {
             this.array.shift();
-        },
+        }
+    }
 
-        unshift: function (v) {
-            this.array.unshift(v);
-            if (this.capacity && this.array.length > this.capacity) {
-                this.array.pop();
-            }
-        },
+    pop() {
+        this.array.pop();
+    }
+
+    shift() {
+        this.array.shift();
+    }
+
+    unshift(v) {
+        this.array.unshift(v);
+        if (this.capacity && this.array.length > this.capacity) {
+            this.array.pop();
+        }
+    }
 
-        remove: function (v) {
-            BI.remove(this.array, v);
-        },
+    remove(v) {
+        remove(this.array, v);
+    }
 
-        splice: function () {
-            this.array.splice.apply(this.array, arguments);
-        },
+    splice() {
+        this.array.splice.apply(this.array, arguments);
+    }
 
-        slice: function () {
-            this.array.slice.apply(this.array, arguments);
-        },
+    slice() {
+        this.array.slice.apply(this.array, arguments);
+    }
 
-        size: function () {
-            return this.array.length;
-        },
+    size() {
+        return this.array.length;
+    }
 
-        each: function (fn, scope) {
-            var scope = scope || window;
-            var fn = fn || null;
-            if (fn == null || typeof (fn) !== "function") {
-                return;
-            }
-            for (var i = 0; i < this.array.length; i++) {
-                var re = fn.call(scope, i, this.array[i], this.array);
-                if (re == false) {
-                    break;
-                }
+    each(fn, scope) {
+        scope = scope || window;
+        fn = fn || null;
+        if (fn == null || typeof (fn) !== "function") {
+            return;
+        }
+        for (let i = 0; i < this.array.length; i++) {
+            const re = fn.call(scope, i, this.array[i], this.array);
+            if (re === false) {
+                break;
             }
-        },
+        }
+    }
 
-        toArray: function () {
-            return this.array;
-        },
+    toArray() {
+        return this.array;
+    }
+
+    fromArray(array) {
+        array.each(v => this.push(v));
+    }
+
+    clear() {
+        this.array.length = 0;
+    }
+}
 
-        fromArray: function (array) {
-            var self = this;
-            BI.each(array, function (i, v) {
-                self.push(v);
-            });
-        },
 
-        clear: function () {
-            this.array.length = 0;
-        }
-    };
-})();

src/core/structure/sectionManager.js

@@ -1,5 +1,7 @@
-!(function () {
-    var Section = function (height, width, x, y) {
+import {each, keys, map, size} from "../2.base";
+
+class Section {
+    constructor(height, width, x, y) {
         this.height = height;
         this.width = width;
         this.x = x;
@@ -7,82 +9,79 @@
 
         this._indexMap = {};
         this._indices = [];
-    };
-
-    Section.prototype = {
-        constructor: Section,
-        addCellIndex: function (index) {
-            if (!this._indexMap[index]) {
-                this._indexMap[index] = true;
-                this._indices.push(index);
-            }
-        },
+    }
 
-        getCellIndices: function () {
-            return this._indices;
+    addCellIndex(index) {
+        if (!this._indexMap[index]) {
+            this._indexMap[index] = true;
+            this._indices.push(index);
         }
-    };
+    }
+
+    getCellIndices() {
+        return this._indices;
+    }
+}
 
-    var SECTION_SIZE = 100;
-    BI.SectionManager = function (sectionSize) {
-        this._sectionSize = sectionSize || SECTION_SIZE;
+const SECTION_SIZE = 100;
+
+export class SectionManager {
+    constructor(sectionSize = SECTION_SIZE) {
+        this._sectionSize = sectionSize;
         this._cellMetadata = [];
         this._sections = {};
-    };
-
-    BI.SectionManager.prototype = {
-        constructor: BI.SectionManager,
-        getCellIndices: function (height, width, x, y) {
-            var indices = {};
+    }
 
-            BI.each(this.getSections(height, width, x, y), function (i, section) {
-                BI.each(section.getCellIndices(), function (j, index) {
-                    indices[index] = index;
-                });
-            });
+    getCellIndices(height, width, x, y) {
+        const indices = {};
 
-            return BI.map(BI.keys(indices), function (i, index) {
-                return indices[index];
+        each(this.getSections(height, width, x, y), function (i, section) {
+            each(section.getCellIndices(), function (j, index) {
+                indices[index] = index;
             });
-        },
+        });
 
-        getCellMetadata: function (index) {
-            return this._cellMetadata[index];
-        },
+        return map(keys(indices), function (i, index) {
+            return indices[index];
+        });
+    }
 
-        getSections: function (height, width, x, y) {
-            var sectionXStart = Math.floor(x / this._sectionSize);
-            var sectionXStop = Math.floor((x + width - 1) / this._sectionSize);
-            var sectionYStart = Math.floor(y / this._sectionSize);
-            var sectionYStop = Math.floor((y + height - 1) / this._sectionSize);
+    getCellMetadata(index) {
+        return this._cellMetadata[index];
+    }
 
-            var sections = [];
+    getSections(height, width, x, y) {
+        const sectionXStart = Math.floor(x / this._sectionSize);
+        const sectionXStop = Math.floor((x + width - 1) / this._sectionSize);
+        const sectionYStart = Math.floor(y / this._sectionSize);
+        const sectionYStop = Math.floor((y + height - 1) / this._sectionSize);
 
-            for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) {
-                for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) {
-                    var key = sectionX + "." + sectionY;
+        const sections = [];
 
-                    if (!this._sections[key]) {
-                        this._sections[key] = new Section(this._sectionSize, this._sectionSize, sectionX * this._sectionSize, sectionY * this._sectionSize);
-                    }
+        for (let sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) {
+            for (let sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) {
+                const key = sectionX + "." + sectionY;
 
-                    sections.push(this._sections[key]);
+                if (!this._sections[key]) {
+                    this._sections[key] = new Section(this._sectionSize, this._sectionSize, sectionX * this._sectionSize, sectionY * this._sectionSize);
                 }
+
+                sections.push(this._sections[key]);
             }
+        }
 
-            return sections;
-        },
+        return sections;
+    }
 
-        getTotalSectionCount: function () {
-            return BI.size(this._sections);
-        },
+    getTotalSectionCount() {
+        return size(this._sections);
+    }
 
-        registerCell: function (cellMetadatum, index) {
-            this._cellMetadata[index] = cellMetadatum;
+    registerCell(cellMetadatum, index) {
+        this._cellMetadata[index] = cellMetadatum;
 
-            BI.each(this.getSections(cellMetadatum.height, cellMetadatum.width, cellMetadatum.x, cellMetadatum.y), function (i, section) {
-                section.addCellIndex(index);
-            });
-        }
-    };
-})();
+        each(this.getSections(cellMetadatum.height, cellMetadatum.width, cellMetadatum.x, cellMetadatum.y), function (i, section) {
+            section.addCellIndex(index);
+        });
+    }
+}

src/core/structure/tree.js

@@ -1,517 +1,521 @@
-(function () {
-    BI.Tree = function () {
-        this.root = new BI.Node(BI.UUID());
-    };
-
-    BI.Tree.prototype = {
-        constructor: BI.Tree,
-        addNode: function (node, newNode, index) {
-            if (BI.isNull(newNode)) {
-                this.root.addChild(node, index);
-            } else if (BI.isNull(node)) {
-                this.root.addChild(newNode, index);
-            } else {
-                node.addChild(newNode, index);
-            }
-        },
-
-        isRoot: function (node) {
-            return node === this.root;
-        },
-
-        getRoot: function () {
-            return this.root;
-        },
-
-        clear: function () {
-            this.root.clear();
-        },
-
-        initTree: function (nodes) {
-            var self = this;
-            this.clear();
-            var queue = [];
-            BI.each(nodes, function (i, node) {
-                var n = new BI.Node(node);
-                n.set("data", node);
-                self.addNode(n);
-                queue.push(n);
-            });
-            while (!BI.isEmpty(queue)) {
-                var parent = queue.shift();
-                var node = parent.get("data");
-                BI.each(node.children, function (i, child) {
-                    var n = new BI.Node(child);
-                    n.set("data", child);
-                    queue.push(n);
-                    self.addNode(parent, n);
-                });
-            }
-        },
+import {
+    isObject,
+    UUID,
+    extend,
+    isEmpty,
+    isArray,
+    first,
+    last,
+    findIndex,
+    isUndefined,
+    isNull,
+    each,
+    deepClone,
+    isEqual, some, every, clone
+} from "../2.base";
+
+export class Node {
+    constructor(id) {
+        if (isObject(id)) {
+            extend(this, id);
+        } else {
+            this.id = id;
+        }
+        this.clear();
+    }
 
-        _toJSON: function (node) {
-            var self = this;
-            var children = [];
-            BI.each(node.getChildren(), function (i, child) {
-                children.push(self._toJSON(child));
-            });
-            return BI.extend({
-                id: node.id
-            }, BI.deepClone(node.get("data")), (children.length > 0 ? {
-                    children: children
-                } : {}));
-        },
-
-        toJSON: function (node) {
-            var self = this, result = [];
-            BI.each((node || this.root).getChildren(), function (i, child) {
-                result.push(self._toJSON(child));
-            });
-            return result;
-        },
-
-        _toJSONWithNode: function (node) {
-            var self = this;
-            var children = [];
-            BI.each(node.getChildren(), function (i, child) {
-                children.push(self._toJSONWithNode(child));
-            });
-            return BI.extend({
-                id: node.id
-            }, BI.deepClone(node.get("data")), {
-                node: node
-            }, (children.length > 0 ? {
-                    children: children
-                } : {}));
-        },
-
-        toJSONWithNode: function (node) {
-            var self = this, result = [];
-            BI.each((node || this.root).getChildren(), function (i, child) {
-                result.push(self._toJSONWithNode(child));
+    set(key, value) {
+        if (isObject(key)) {
+            extend(this, key);
+            return;
+        }
+        this[key] = value;
+    }
+
+    get(key) {
+        return this[key];
+    }
+
+    isLeaf() {
+        return isEmpty(this.children);
+    }
+
+    getChildren() {
+        return this.children;
+    }
+
+    getChildrenLength() {
+        return this.children.length;
+    }
+
+    getFirstChild() {
+        return first(this.children);
+    }
+
+    getLastChild() {
+        return last(this.children);
+    }
+
+    setLeft(left) {
+        this.left = left;
+    }
+
+    getLeft() {
+        return this.left;
+    }
+
+    setRight(right) {
+        this.right = right;
+    }
+
+    getRight() {
+        return this.right;
+    }
+
+    setParent(parent) {
+        this.parent = parent;
+    }
+
+    getParent() {
+        return this.parent;
+    }
+
+    getChild(index) {
+        return this.children[index];
+    }
+
+    getChildIndex(id) {
+        return findIndex(this.children, function (i, ch) {
+            return ch.get("id") === id;
+        });
+    }
+
+    removeChild(id) {
+        this.removeChildByIndex(this.getChildIndex(id));
+    }
+
+    removeChildByIndex(index) {
+        const before = this.getChild(index - 1);
+        const behind = this.getChild(index + 1);
+        if (before != null) {
+            before.setRight(behind || null);
+        }
+        if (behind != null) {
+            behind.setLeft(before || null);
+        }
+        this.children.splice(index, 1);
+    }
+
+    removeAllChilds() {
+        this.children = [];
+    }
+
+    addChild(child, index) {
+        let cur = null;
+        if (isUndefined(index)) {
+            cur = this.children.length - 1;
+        } else {
+            cur = index - 1;
+        }
+        child.setParent(this);
+        if (cur >= 0) {
+            this.getChild(cur) && this.getChild(cur).setRight(child);
+            child.setLeft(this.getChild(cur));
+        }
+        if (isUndefined(index)) {
+            this.children.push(child);
+        } else {
+            this.children.splice(index, 0, child);
+        }
+    }
+
+    equals(obj) {
+        return this === obj || this.id === obj.id;
+    }
+
+    clear() {
+        this.parent = null;
+        this.left = null;
+        this.right = null;
+        this.children = [];
+    }
+}
+
+export class Tree {
+    constructor() {
+        this.root = new Node(UUID());
+    }
+
+    addNode(node, newNode, index) {
+        if (isNull(newNode)) {
+            this.root.addChild(node, index);
+        } else if (isNull(node)) {
+            this.root.addChild(newNode, index);
+        } else {
+            node.addChild(newNode, index);
+        }
+    }
+
+    isRoot(node) {
+        return node === this.root;
+    }
+
+    getRoot() {
+        return this.root;
+    }
+
+    clear() {
+        this.root.clear();
+    }
+
+    initTree(nodes) {
+        this.clear();
+        const queue = [];
+        each(nodes, (i, node) => {
+            const n = new Node(node);
+            n.set("data", node);
+            this.addNode(n);
+            queue.push(n);
+        });
+        while (!isEmpty(queue)) {
+            const parent = queue.shift();
+            const node = parent.get("data");
+            each(node.children, (i, child) => {
+                const n = new Node(child);
+                n.set("data", child);
+                queue.push(n);
+                this.addNode(parent, n);
             });
-            return result;
-        },
+        }
+    }
+
+    _toJSON(node) {
+        const children = [];
+        each(node.getChildren(), (i, child) => {
+            children.push(this._toJSON(child));
+        });
+        return extend({
+            id: node.id,
+        }, deepClone(node.get("data")), (children.length > 0 ? {
+            children: children,
+        } : {}));
+    }
+
+    toJSON(node) {
+        const result = [];
+        each((node || this.root).getChildren(), (i, child) => {
+            result.push(this._toJSON(child));
+        });
+        return result;
+    }
+
+    _toJSONWithNode(node) {
+        const children = [];
+        each(node.getChildren(), (i, child) => {
+            children.push(this._toJSONWithNode(child));
+        });
+        return extend({
+            id: node.id,
+        }, deepClone(node.get("data")), {
+            node: node,
+        }, (children.length > 0 ? {
+            children: children,
+        } : {}));
+    }
+
+    toJSONWithNode(node) {
+        const result = [];
+        each((node || this.root).getChildren(), (i, child) => {
+            result.push(this._toJSONWithNode(child));
+        });
+        return result;
+    }
+
+    search(root, target, param) {
+        if (!(root instanceof Node)) {
+            return this.search(this.root, root, target);
+        }
+        let next = null;
 
-        search: function (root, target, param) {
-            if (!(root instanceof BI.Node)) {
-                return arguments.callee.apply(this, [this.root, root, target]);
+        if (isNull(target)) {
+            return null;
+        }
+        if (isEqual(root[param || "id"], target)) {
+            return root;
+        }
+        some(root.getChildren(), (i, child) => {
+            next = this.search(child, target, param);
+            if (null !== next) {
+                return true;
             }
-            var self = this, next = null;
-
-            if (BI.isNull(target)) {
-                return null;
+        });
+        return next;
+    }
+
+    _traverse(node, callback) {
+        let queue = [];
+        queue.push(node);
+        while (!isEmpty(queue)) {
+            const temp = queue.shift();
+            const b = callback && callback(temp);
+            if (b === false) {
+                break;
             }
-            if (BI.isEqual(root[param || "id"], target)) {
-                return root;
+            if (b === true) {
+                continue;
             }
-            BI.any(root.getChildren(), function (i, child) {
-                next = self.search(child, target, param);
-                if (null !== next) {
-                    return true;
-                }
-            });
-            return next;
-        },
-
-        _traverse: function (node, callback) {
-            var queue = [];
-            queue.push(node);
-            while (!BI.isEmpty(queue)) {
-                var temp = queue.shift();
-                var b = callback && callback(temp);
-                if (b === false) {
-                    break;
-                }
-                if (b === true) {
-                    continue;
-                }
-                if (temp != null) {
-                    queue = queue.concat(temp.getChildren());
-                }
+            if (temp != null) {
+                queue = queue.concat(temp.getChildren());
             }
-        },
-
-        traverse: function (callback) {
-            this._traverse(this.root, callback);
-        },
-
-        _recursion: function (node, route, callback) {
-            var self = this;
-            return BI.every(node.getChildren(), function (i, child) {
-                var next = BI.clone(route);
-                next.push(child.id);
-                var b = callback && callback(child, next);
-                if (b === false) {
-                    return false;
-                }
-                if (b === true) {
-                    return true;
-                }
-                return self._recursion(child, next, callback);
-            });
-        },
-
-        recursion: function (callback) {
-            this._recursion(this.root, [], callback);
-        },
-
-        inOrderTraverse: function (callback) {
-            this._inOrderTraverse(this.root, callback);
-        },
-
-        // 中序遍历(递归)
-        _inOrderTraverse: function (node, callback) {
-            if (node != null) {
-                this._inOrderTraverse(node.getLeft());
-                callback && callback(node);
-                this._inOrderTraverse(node.getRight());
+        }
+    }
+
+    traverse(callback) {
+        this._traverse(this.root, callback);
+    }
+
+    _recursion(node, route, callback) {
+        return every(node.getChildren(), (i, child) => {
+            const next = clone(route);
+            next.push(child.id);
+            const b = callback && callback(child, next);
+            if (b === false) {
+                return false;
             }
-        },
-
-        // 中序遍历(非递归)
-        nrInOrderTraverse: function (callback) {
-
-            var stack = [];
-            var node = this.root;
-            while (node != null || !BI.isEmpty(stack)) {
-                while (node != null) {
-                    stack.push(node);
-                    node = node.getLeft();
-                }
-                node = stack.pop();
-                callback && callback(node);
-                node = node.getRight();
+            if (b === true) {
+                return true;
             }
-        },
+            return this._recursion(child, next, callback);
+        });
+    }
+
+    recursion(callback) {
+        this._recursion(this.root, [], callback);
+    }
+
+    inOrderTraverse(callback) {
+        this._inOrderTraverse(this.root, callback);
+    }
+
+    // 中序遍历(递归)
+    _inOrderTraverse(node, callback) {
+        if (node != null) {
+            this._inOrderTraverse(node.getLeft());
+            callback && callback(node);
+            this._inOrderTraverse(node.getRight());
+        }
+    }
 
-        preOrderTraverse: function (callback) {
-            this._preOrderTraverse(this.root, callback);
-        },
+    // 中序遍历(非递归)
+    nrInOrderTraverse(callback) {
 
-        // 先序遍历(递归)
-        _preOrderTraverse: function (node, callback) {
-            if (node != null) {
-                callback && callback(node);
-                this._preOrderTraverse(node.getLeft());
-                this._preOrderTraverse(node.getRight());
+        const stack = [];
+        let node = this.root;
+        while (node != null || !isEmpty(stack)) {
+            while (node != null) {
+                stack.push(node);
+                node = node.getLeft();
             }
-        },
-
-        // 先序遍历（非递归）
-        nrPreOrderTraverse: function (callback) {
-
-            var stack = [];
-            var node = this.root;
+            node = stack.pop();
+            callback && callback(node);
+            node = node.getRight();
+        }
+    }
+
+    preOrderTraverse(callback) {
+        this._preOrderTraverse(this.root, callback);
+    }
+
+    // 先序遍历(递归)
+    _preOrderTraverse(node, callback) {
+        if (node != null) {
+            callback && callback(node);
+            this._preOrderTraverse(node.getLeft());
+            this._preOrderTraverse(node.getRight());
+        }
+    }
 
-            while (node != null || !BI.isEmpty(stack)) {
+    // 先序遍历（非递归）
+    nrPreOrderTraverse(callback) {
 
-                while (node != null) {
-                    callback && callback(node);
-                    stack.push(node);
-                    node = node.getLeft();
-                }
-                node = stack.pop();
-                node = node.getRight();
-            }
-        },
+        const stack = [];
+        let node = this.root;
 
-        postOrderTraverse: function (callback) {
-            this._postOrderTraverse(this.root, callback);
-        },
+        while (node != null || !isEmpty(stack)) {
 
-        // 后序遍历(递归)
-        _postOrderTraverse: function (node, callback) {
-            if (node != null) {
-                this._postOrderTraverse(node.getLeft());
-                this._postOrderTraverse(node.getRight());
+            while (node != null) {
                 callback && callback(node);
+                stack.push(node);
+                node = node.getLeft();
             }
-        },
-
-        // 后续遍历(非递归)
-        nrPostOrderTraverse: function (callback) {
-
-            var stack = [];
-            var node = this.root;
-            var preNode = null;// 表示最近一次访问的节点
-
-            while (node != null || !BI.isEmpty(stack)) {
-
-                while (node != null) {
-                    stack.push(node);
-                    node = node.getLeft();
-                }
-
-                node = BI.last(stack);
-
-                if (node.getRight() == null || node.getRight() == preNode) {
-                    callback && callback(node);
-                    node = stack.pop();
-                    preNode = node;
-                    node = null;
-                } else {
-                    node = node.getRight();
-                }
-            }
+            node = stack.pop();
+            node = node.getRight();
         }
-    };
-
-    BI.Node = function (id) {
-        if (BI.isObject(id)) {
-            BI.extend(this, id);
-        } else {
-            this.id = id;
+    }
+
+    postOrderTraverse(callback) {
+        this._postOrderTraverse(this.root, callback);
+    }
+
+    // 后序遍历(递归)
+    _postOrderTraverse(node, callback) {
+        if (node != null) {
+            this._postOrderTraverse(node.getLeft());
+            this._postOrderTraverse(node.getRight());
+            callback && callback(node);
         }
-        this.clear.apply(this, arguments);
-    };
-
-    BI.Node.prototype = {
-        constructor: BI.Node,
-
-        set: function (key, value) {
-            if (BI.isObject(key)) {
-                BI.extend(this, key);
-                return;
-            }
-            this[key] = value;
-        },
-
-        get: function (key) {
-            return this[key];
-        },
-
-        isLeaf: function () {
-            return BI.isEmpty(this.children);
-        },
-
-        getChildren: function () {
-            return this.children;
-        },
-
-        getChildrenLength: function () {
-            return this.children.length;
-        },
-
-        getFirstChild: function () {
-            return BI.first(this.children);
-        },
-
-        getLastChild: function () {
-            return BI.last(this.children);
-        },
+    }
 
-        setLeft: function (left) {
-            this.left = left;
-        },
+    // 后续遍历(非递归)
+    nrPostOrderTraverse(callback) {
 
-        getLeft: function () {
-            return this.left;
-        },
+        const stack = [];
+        let node = this.root;
+        let preNode = null;// 表示最近一次访问的节点
 
-        setRight: function (right) {
-            this.right = right;
-        },
+        while (node != null || !isEmpty(stack)) {
 
-        getRight: function () {
-            return this.right;
-        },
-
-        setParent: function (parent) {
-            this.parent = parent;
-        },
-
-        getParent: function () {
-            return this.parent;
-        },
-
-        getChild: function (index) {
-            return this.children[index];
-        },
-
-        getChildIndex: function (id) {
-            return BI.findIndex(this.children, function (i, ch) {
-                return ch.get("id") === id;
-            });
-        },
-
-        removeChild: function (id) {
-            this.removeChildByIndex(this.getChildIndex(id));
-        },
-
-        removeChildByIndex: function (index) {
-            var before = this.getChild(index - 1);
-            var behind = this.getChild(index + 1);
-            if (before != null) {
-                before.setRight(behind || null);
-            }
-            if (behind != null) {
-                behind.setLeft(before || null);
+            while (node != null) {
+                stack.push(node);
+                node = node.getLeft();
             }
-            this.children.splice(index, 1);
-        },
 
-        removeAllChilds: function () {
-            this.children = [];
-        },
+            node = last(stack);
 
-        addChild: function (child, index) {
-            var cur = null;
-            if (BI.isUndefined(index)) {
-                cur = this.children.length - 1;
+            if (node.getRight() == null || node.getRight() === preNode) {
+                callback && callback(node);
+                node = stack.pop();
+                preNode = node;
+                node = null;
             } else {
-                cur = index - 1;
+                node = node.getRight();
             }
-            child.setParent(this);
-            if (cur >= 0) {
-                this.getChild(cur) && this.getChild(cur).setRight(child);
-                child.setLeft(this.getChild(cur));
+        }
+    }
+
+    static transformToArrayFormat(nodes, pId, childKey) {
+        if (!nodes) return [];
+        let r = [];
+        childKey = childKey || "children";
+        if (isArray(nodes)) {
+            for (let i = 0, l = nodes.length; i < l; i++) {
+                const node = clone(nodes[i]);
+                node.pId = node.pId == null ? pId : node.pId;
+                delete node.children;
+                r.push(node);
+                if (nodes[i][childKey]) {
+                    r = r.concat(Tree.transformToArrayFormat(nodes[i][childKey], node.id));
+                }
             }
-            if (BI.isUndefined(index)) {
-                this.children.push(child);
-            } else {
-                this.children.splice(index, 0, child);
+        } else {
+            const newNodes = clone(nodes);
+            newNodes.pId = newNodes.pId == null ? pId : newNodes.pId;
+            delete newNodes.children;
+            r.push(newNodes);
+            if (nodes[childKey]) {
+                r = r.concat(Tree.transformToArrayFormat(nodes[childKey], newNodes.id));
             }
-        },
-
-        equals: function (obj) {
-            return this === obj || this.id === obj.id;
-        },
+        }
+        return r;
+    }
 
-        clear: function () {
-            this.parent = null;
-            this.left = null;
-            this.right = null;
-            this.children = [];
+    static arrayFormat(nodes, pId) {
+        if (!nodes) {
+            return [];
         }
-    };
-
-    BI.extend(BI.Tree, {
-        transformToArrayFormat: function (nodes, pId, childKey) {
-            if (!nodes) return [];
-            var r = [];
-            childKey = childKey || "children";
-            if (BI.isArray(nodes)) {
-                for (var i = 0, l = nodes.length; i < l; i++) {
-                    var node = BI.clone(nodes[i]);
-                    node.pId = node.pId == null ? pId : node.pId;
-                    delete node.children;
-                    r.push(node);
-                    if (nodes[i][childKey]) {
-                        r = r.concat(BI.Tree.transformToArrayFormat(nodes[i][childKey], node.id));
-                    }
-                }
-            } else {
-                var newNodes = BI.clone(nodes);
-                newNodes.pId = newNodes.pId == null ? pId : newNodes.pId;
-                delete newNodes.children;
-                r.push(newNodes);
-                if (nodes[childKey]) {
-                    r = r.concat(BI.Tree.transformToArrayFormat(nodes[childKey], newNodes.id));
+        let r = [];
+        if (isArray(nodes)) {
+            for (let i = 0, l = nodes.length; i < l; i++) {
+                const node = nodes[i];
+                node.pId = node.pId == null ? pId : node.pId;
+                r.push(node);
+                if (nodes[i]["children"]) {
+                    r = r.concat(Tree.arrayFormat(nodes[i]["children"], node.id));
                 }
             }
-            return r;
-        },
-
-        arrayFormat: function (nodes, pId) {
-            if (!nodes) {
-                return [];
-            }
-            var r = [];
-            if (BI.isArray(nodes)) {
-                for (var i = 0, l = nodes.length; i < l; i++) {
-                    var node = nodes[i];
-                    node.pId = node.pId == null ? pId : node.pId;
-                    r.push(node);
-                    if (nodes[i]["children"]) {
-                        r = r.concat(BI.Tree.arrayFormat(nodes[i]["children"], node.id));
-                    }
-                }
-            } else {
-                var newNodes = nodes;
-                newNodes.pId = newNodes.pId == null ? pId : newNodes.pId;
-                r.push(newNodes);
-                if (nodes["children"]) {
-                    r = r.concat(BI.Tree.arrayFormat(nodes["children"], newNodes.id));
-                }
+        } else {
+            const newNodes = nodes;
+            newNodes.pId = newNodes.pId == null ? pId : newNodes.pId;
+            r.push(newNodes);
+            if (nodes["children"]) {
+                r = r.concat(Tree.arrayFormat(nodes["children"], newNodes.id));
             }
-            return r;
-        },
+        }
+        return r;
+    }
 
-        transformToTreeFormat: function (sNodes) {
-            var i, l;
-            if (!sNodes) {
-                return [];
-            }
+    static transformToTreeFormat(sNodes) {
+        let i, l;
+        if (!sNodes) {
+            return [];
+        }
 
-            if (BI.isArray(sNodes)) {
-                var r = [];
-                var tmpMap = {};
-                for (i = 0, l = sNodes.length; i < l; i++) {
-                    if (BI.isNull(sNodes[i].id)) {
-                        return sNodes;
-                    }
-                    tmpMap[sNodes[i].id] = BI.clone(sNodes[i]);
+        if (isArray(sNodes)) {
+            const r = [];
+            const tmpMap = {};
+            for (i = 0, l = sNodes.length; i < l; i++) {
+                if (isNull(sNodes[i].id)) {
+                    return sNodes;
                 }
-                for (i = 0, l = sNodes.length; i < l; i++) {
-                    if (tmpMap[sNodes[i].pId] && sNodes[i].id !== sNodes[i].pId) {
-                        if (!tmpMap[sNodes[i].pId].children) {
-                            tmpMap[sNodes[i].pId].children = [];
-                        }
-                        tmpMap[sNodes[i].pId].children.push(tmpMap[sNodes[i].id]);
-                    } else {
-                        r.push(tmpMap[sNodes[i].id]);
+                tmpMap[sNodes[i].id] = clone(sNodes[i]);
+            }
+            for (i = 0, l = sNodes.length; i < l; i++) {
+                if (tmpMap[sNodes[i].pId] && sNodes[i].id !== sNodes[i].pId) {
+                    if (!tmpMap[sNodes[i].pId].children) {
+                        tmpMap[sNodes[i].pId].children = [];
                     }
-                    delete tmpMap[sNodes[i].id].pId;
+                    tmpMap[sNodes[i].pId].children.push(tmpMap[sNodes[i].id]);
+                } else {
+                    r.push(tmpMap[sNodes[i].id]);
                 }
-                return r;
+                delete tmpMap[sNodes[i].id].pId;
             }
-            return [sNodes];
+            return r;
+        }
+        return [sNodes];
 
-        },
+    }
 
-        treeFormat: function (sNodes) {
-            var i, l;
-            if (!sNodes) {
-                return [];
-            }
+    static treeFormat(sNodes) {
+        let i, l;
+        if (!sNodes) {
+            return [];
+        }
 
-            if (BI.isArray(sNodes)) {
-                var r = [];
-                var tmpMap = {};
-                for (i = 0, l = sNodes.length; i < l; i++) {
-                    if (BI.isNull(sNodes[i].id)) {
-                        return sNodes;
-                    }
-                    tmpMap[sNodes[i].id] = sNodes[i];
+        if (isArray(sNodes)) {
+            const r = [];
+            const tmpMap = {};
+            for (i = 0, l = sNodes.length; i < l; i++) {
+                if (isNull(sNodes[i].id)) {
+                    return sNodes;
                 }
-                for (i = 0, l = sNodes.length; i < l; i++) {
-                    if (tmpMap[sNodes[i].pId] && sNodes[i].id !== sNodes[i].pId) {
-                        if (!tmpMap[sNodes[i].pId].children) {
-                            tmpMap[sNodes[i].pId].children = [];
-                        }
-                        tmpMap[sNodes[i].pId].children.push(tmpMap[sNodes[i].id]);
-                    } else {
-                        r.push(tmpMap[sNodes[i].id]);
+                tmpMap[sNodes[i].id] = sNodes[i];
+            }
+            for (i = 0, l = sNodes.length; i < l; i++) {
+                if (tmpMap[sNodes[i].pId] && sNodes[i].id !== sNodes[i].pId) {
+                    if (!tmpMap[sNodes[i].pId].children) {
+                        tmpMap[sNodes[i].pId].children = [];
                     }
+                    tmpMap[sNodes[i].pId].children.push(tmpMap[sNodes[i].id]);
+                } else {
+                    r.push(tmpMap[sNodes[i].id]);
                 }
-                return r;
             }
-            return [sNodes];
+            return r;
+        }
+        return [sNodes];
 
-        },
+    }
 
-        traversal: function (array, callback, pNode) {
-            if (BI.isNull(array)) {
-                return;
-            }
-            var self = this;
-            BI.some(array, function (i, item) {
-                if (callback(i, item, pNode) === false) {
-                    return true;
-                }
-                self.traversal(item.children, callback, item);
-            });
+    static traversal(array, callback, pNode) {
+        if (isNull(array)) {
+            return;
         }
-    });
-})();
+        some(array, (i, item) => {
+            if (callback(i, item, pNode) === false) {
+                return true;
+            }
+            this.traversal(item.children, callback, item);
+        });
+    }
+}

src/core/structure/vector.js

@@ -1,27 +1,29 @@
 // 向量操作
-BI.Vector = function (x, y) {
-    this.x = x;
-    this.y = y;
-};
-BI.Vector.prototype = {
-    constructor: BI.Vector,
-    cross: function (v) {
+export class Vector {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    cross(v) {
         return (this.x * v.y - this.y * v.x);
-    },
-    length: function (v) {
+    }
+
+    length(v) {
         return (Math.sqrt(this.x * v.x + this.y * v.y));
     }
-};
-BI.Region = function (x, y, w, h) {
-    this.x = x;
-    this.y = y;
-    this.w = w;
-    this.h = h;
-};
-BI.Region.prototype = {
-    constructor: BI.Region,
+}
+
+export class Region {
+    constructor(x, y, w, h) {
+        this.x = x;
+        this.y = y;
+        this.w = w;
+        this.h = h;
+    }
+
     // 判断两个区域是否相交，若相交，则要么顶点互相包含，要么矩形边界（或对角线）相交
-    isIntersects: function (obj) {
+    isIntersects(obj) {
         if (this.isPointInside(obj.x, obj.y) ||
             this.isPointInside(obj.x + obj.w, obj.y) ||
             this.isPointInside(obj.x, obj.y + obj.h) ||
@@ -34,17 +36,18 @@ BI.Region.prototype = {
             return true;
         } else if (obj.x != null && obj.y != null)// 判断矩形对角线相交 |v1 X v2||v1 X v3| < 0
         {
-            var vector1 = new BI.Vector(this.w, this.h);// 矩形对角线向量
-            var vector2 = new BI.Vector(obj.x - this.x, obj.y - this.y);
-            var vector3 = new BI.Vector(vector2.x + obj.w, vector2.y + obj.h);
+            const vector1 = new Vector(this.w, this.h);// 矩形对角线向量
+            const vector2 = new Vector(obj.x - this.x, obj.y - this.y);
+            const vector3 = new Vector(vector2.x + obj.w, vector2.y + obj.h);
             if ((vector1.cross(vector2) * vector1.cross(vector3)) < 0) {
                 return true;
             }
         }
         return false;
-    },
+    }
+
     // 判断一个点是否在这个区域内部
-    isPointInside: function (x, y) {
+    isPointInside(x, y) {
         if (this.x == null || this.y == null) {
             return false;
         }
@@ -52,12 +55,14 @@ BI.Region.prototype = {
             return true;
         }
         return false;
-    },
+    }
+
     // 返回区域的重心，因为是矩形所以返回中点
-    getPosition: function () {
-        var pos = [];
+    getPosition() {
+        const pos = [];
         pos.push(this.x + this.w / 2);
         pos.push(this.y + this.h / 2);
         return pos;
     }
-};
+}
+