vislite 0.6.0 → 0.7.0

package/src/formatColor.ts

@@ -1,45 +1,45 @@
-const toHex = (value: number) => {
-    const hex = value.toString(16)
-    return hex.length == 1 ? ("0" + hex) : hex
-}
-
-export default function (color: string, format: string) {
-
-    const colorNode = document.getElementsByTagName('head')[0]
-    colorNode.style['color'] = color
-
-    // 获取结点的全部样式
-    const allStyle = document.defaultView && document.defaultView.getComputedStyle ?
-        document.defaultView.getComputedStyle(colorNode, null) :
-        (colorNode as any).currentStyle
-
-    const oralFormat = allStyle.getPropertyValue('color').replace(/rgba?\(/, '').replace(")", "").split(',')
-    for (let index = 0; index < oralFormat.length; index++) {
-        oralFormat[index] = +oralFormat[index]
-    }
-    oralFormat.push(1)
-
-    switch (format) {
-        case "3d": {
-            return [
-                oralFormat[0] / 255,
-                oralFormat[1] / 255,
-                oralFormat[2] / 255,
-                oralFormat[3]
-            ]
-        }
-        case "rgba": {
-            return `rgba(${oralFormat[0]}, ${oralFormat[1]}, ${oralFormat[2]}, ${oralFormat[3]})`
-        }
-        case "rgb": {
-            return `rgb(${oralFormat[0]}, ${oralFormat[1]}, ${oralFormat[2]})`
-        }
-        case "hexAlpha": {
-            return `#${toHex(oralFormat[0])}${toHex(oralFormat[1])}${toHex(oralFormat[2])}${toHex(+(oralFormat[3] * 255).toFixed(0))}`
-        }
-        case "hex": {
-            return `#${toHex(oralFormat[0])}${toHex(oralFormat[1])}${toHex(oralFormat[2])}`
-        }
-    }
-    throw new Error("Unsupported color format: " + format)
+const toHex = (value: number) => {
+    const hex = value.toString(16)
+    return hex.length == 1 ? ("0" + hex) : hex
+}
+
+export default function (color: string, format: string) {
+
+    const colorNode = document.getElementsByTagName('head')[0]
+    colorNode.style['color'] = color
+
+    // 获取结点的全部样式
+    const allStyle = document.defaultView && document.defaultView.getComputedStyle ?
+        document.defaultView.getComputedStyle(colorNode, null) :
+        (colorNode as any).currentStyle
+
+    const oralFormat = allStyle.getPropertyValue('color').replace(/rgba?\(/, '').replace(")", "").split(',')
+    for (let index = 0; index < oralFormat.length; index++) {
+        oralFormat[index] = +oralFormat[index]
+    }
+    oralFormat.push(1)
+
+    switch (format) {
+        case "3d": {
+            return [
+                oralFormat[0] / 255,
+                oralFormat[1] / 255,
+                oralFormat[2] / 255,
+                oralFormat[3]
+            ]
+        }
+        case "rgba": {
+            return `rgba(${oralFormat[0]}, ${oralFormat[1]}, ${oralFormat[2]}, ${oralFormat[3]})`
+        }
+        case "rgb": {
+            return `rgb(${oralFormat[0]}, ${oralFormat[1]}, ${oralFormat[2]})`
+        }
+        case "hexAlpha": {
+            return `#${toHex(oralFormat[0])}${toHex(oralFormat[1])}${toHex(oralFormat[2])}${toHex(+(oralFormat[3] * 255).toFixed(0))}`
+        }
+        case "hex": {
+            return `#${toHex(oralFormat[0])}${toHex(oralFormat[1])}${toHex(oralFormat[2])}`
+        }
+    }
+    throw new Error("Unsupported color format: " + format)
 }

package/src/getLoopColors.ts

@@ -1,42 +1,42 @@
-// 获取一组循环色彩
-export default function (num: number, alpha: number = 1) {
-    // 颜色集合
-    const colorList = [
-        'rgba(84,112,198,' + alpha + ")", 'rgba(145,204,117,' + alpha + ")",
-        'rgba(250,200,88,' + alpha + ")", 'rgba(238,102,102,' + alpha + ")",
-        'rgba(115,192,222,' + alpha + ")", 'rgba(59,162,114,' + alpha + ")",
-        'rgba(252,132,82,' + alpha + ")", 'rgba(154,96,180,' + alpha + ")",
-        'rgba(234,124,204,' + alpha + ")"
-    ]
-
-    let colors: string[] = []
-
-    // 根据情况返回颜色数组
-    if (num <= colorList.length) {
-        // 这种情况就不需要任何处理
-        return colorList
-    } else {
-        // 如果正好是集合长度的倍数
-        if (num % colorList.length == 0) {
-            // 将颜色数组循环加入后再返回
-            for (let i = 0; i < (num / colorList.length); i++) {
-                colors = colors.concat(colorList)
-            }
-        } else {
-            for (let j = 1; j < (num / colorList.length); j++) {
-                colors = colors.concat(colorList)
-            }
-            // 防止最后一个颜色和第一个颜色重复
-            if (num % colorList.length == 1) {
-                colors = colors.concat(colorList[4])
-            } else {
-                for (let k = 0; k < num % colorList.length; k++) {
-                    colors = colors.concat(colorList[k])
-                }
-            }
-        }
-    }
-
-    // 返回结果
-    return colors
-}
+// 获取一组循环色彩
+export default function (num: number, alpha: number = 1) {
+    // 颜色集合
+    const colorList = [
+        'rgba(84,112,198,' + alpha + ")", 'rgba(145,204,117,' + alpha + ")",
+        'rgba(250,200,88,' + alpha + ")", 'rgba(238,102,102,' + alpha + ")",
+        'rgba(115,192,222,' + alpha + ")", 'rgba(59,162,114,' + alpha + ")",
+        'rgba(252,132,82,' + alpha + ")", 'rgba(154,96,180,' + alpha + ")",
+        'rgba(234,124,204,' + alpha + ")"
+    ]
+
+    let colors: string[] = []
+
+    // 根据情况返回颜色数组
+    if (num <= colorList.length) {
+        // 这种情况就不需要任何处理
+        return colorList
+    } else {
+        // 如果正好是集合长度的倍数
+        if (num % colorList.length == 0) {
+            // 将颜色数组循环加入后再返回
+            for (let i = 0; i < (num / colorList.length); i++) {
+                colors = colors.concat(colorList)
+            }
+        } else {
+            for (let j = 1; j < (num / colorList.length); j++) {
+                colors = colors.concat(colorList)
+            }
+            // 防止最后一个颜色和第一个颜色重复
+            if (num % colorList.length == 1) {
+                colors = colors.concat(colorList[4])
+            } else {
+                for (let k = 0; k < num % colorList.length; k++) {
+                    colors = colors.concat(colorList[k])
+                }
+            }
+        }
+    }
+
+    // 返回结果
+    return colors
+}

package/src/interpolation/Cardinal.ts

@@ -1,111 +1,111 @@
-/**
- * Cardinal三次插值
- * ----------------------------
- * Hermite拟合的计算是，确定两个点和两个点的斜率
- * 用一个y=ax(3)+bx(2)+cx+d的三次多项式来求解
- * 而Cardinal是建立在此基础上
- * 给定需要拟合的两个点和第一个点的前一个点+最后一个点的后一个点
- * 第一个点的斜率由第一个点的前一个点和第二个点的斜率确定
- * 第二个点的斜率由第一个点和第二个点的后一个点的斜率确定
- */
-
-import type CardinalType from '../../types/Cardinal'
-
-import Hermite from './Hermite'
-
-class Cardinal implements CardinalType {
-    readonly name: string = 'Cardinal'
-
-    // 该参数用于调整曲线走势，默认数值t=0，分水岭t=-1，|t-(-1)|的值越大，曲线走势调整的越严重
-    private __t: number
-
-    private __HS: {
-        x: number[],
-        h: Hermite[]
-    }
-    private __i: number
-
-    constructor(t: number = 0) {
-        this.__t = t
-    }
-
-    // 设置点的位置
-    // 参数格式：[[x1, y1], [x2, y2], ... ]
-    // 至少两个点
-    setP(points: number[][]) {
-
-        this.__HS = {
-            "x": [],
-            "h": []
-        };
-        let flag: number,
-            slope = (points[1][1] - points[0][1]) / (points[1][0] - points[0][0]),
-            temp: number
-        this.__HS.x[0] = points[0][0]
-        for (flag = 1; flag < points.length; flag++) {
-            if (points[flag][0] <= points[flag - 1][0]) throw new Error('The point position should be increamented!')
-            this.__HS.x[flag] = points[flag][0]
-
-            // 求点斜率
-
-            // temp = flag < points.length - 1 ?
-            //     (points[flag + 1][1] - points[flag - 1][1]) / (points[flag + 1][0] - points[flag - 1][0]) :
-            //     (points[flag][1] - points[flag - 1][1]) / (points[flag][0] - points[flag - 1][0])
-
-            // 修复超过界限的值问题
-            // 2023年6月25日 于南京
-            if (flag < points.length - 1) {
-                if (
-                    (points[flag + 1][1] > points[flag][1] && points[flag - 1][1] > points[flag][1]) ||
-                    (points[flag + 1][1] < points[flag][1] && points[flag - 1][1] < points[flag][1]) ||
-                    points[flag + 1][1] == points[flag][1] ||
-                    points[flag - 1][1] == points[flag][1]
-                ) {
-                    temp = 0
-                } else {
-                    temp = (points[flag + 1][1] - points[flag - 1][1]) / (points[flag + 1][0] - points[flag - 1][0])
-                }
-            } else {
-                temp = (points[flag][1] - points[flag - 1][1]) / (points[flag][0] - points[flag - 1][0])
-            }
-
-            // 求解两个点直接的插值方程
-            // 第一个点的前一个点直接取第一个点
-            // 最后一个点的后一个点直接取最后一个点
-            this.__HS.h[flag - 1] = new Hermite((1 - this.__t) * 0.5).setP(points[flag - 1][0], points[flag - 1][1], points[flag][0], points[flag][1], slope, temp)
-            slope = temp
-        }
-        return this
-
-    }
-
-    // 根据x值返回y值
-    use(x: number) {
-        if (this.__HS) {
-            this.__i = -1
-
-            // 寻找记录x所在位置的区间
-            // 这里就是寻找对应的拟合函数
-            while (this.__i + 1 < this.__HS.x.length && (x > this.__HS.x[this.__i + 1] || (this.__i == -1 && x >= this.__HS.x[this.__i + 1]))) {
-                this.__i += 1
-            }
-
-            // 由于js浮点运算不准确，我们对于越界的情况进行兼容
-
-            if (this.__i < 0) {
-                return this.__HS.h[0].use(this.__HS.x[0])
-            }
-
-            else if (this.__i >= this.__HS.h.length) {
-                return this.__HS.h[this.__HS.h.length - 1].use(this.__HS.x[this.__HS.x.length - 1])
-            }
-
-            return this.__HS.h[this.__i].use(x)
-        } else {
-            throw new Error('You shoud first set the position!')
-        }
-    }
-
-}
-
+/**
+ * Cardinal三次插值
+ * ----------------------------
+ * Hermite拟合的计算是，确定两个点和两个点的斜率
+ * 用一个y=ax(3)+bx(2)+cx+d的三次多项式来求解
+ * 而Cardinal是建立在此基础上
+ * 给定需要拟合的两个点和第一个点的前一个点+最后一个点的后一个点
+ * 第一个点的斜率由第一个点的前一个点和第二个点的斜率确定
+ * 第二个点的斜率由第一个点和第二个点的后一个点的斜率确定
+ */
+
+import type CardinalType from '../../types/Cardinal'
+
+import Hermite from './Hermite'
+
+class Cardinal implements CardinalType {
+    readonly name: string = 'Cardinal'
+
+    // 该参数用于调整曲线走势，默认数值t=0，分水岭t=-1，|t-(-1)|的值越大，曲线走势调整的越严重
+    private __t: number
+
+    private __HS: {
+        x: number[],
+        h: Hermite[]
+    }
+    private __i: number
+
+    constructor(t: number = 0) {
+        this.__t = t
+    }
+
+    // 设置点的位置
+    // 参数格式：[[x1, y1], [x2, y2], ... ]
+    // 至少两个点
+    setP(points: number[][]) {
+
+        this.__HS = {
+            "x": [],
+            "h": []
+        };
+        let flag: number,
+            slope = (points[1][1] - points[0][1]) / (points[1][0] - points[0][0]),
+            temp: number
+        this.__HS.x[0] = points[0][0]
+        for (flag = 1; flag < points.length; flag++) {
+            if (points[flag][0] <= points[flag - 1][0]) throw new Error('The point position should be increamented!')
+            this.__HS.x[flag] = points[flag][0]
+
+            // 求点斜率
+
+            // temp = flag < points.length - 1 ?
+            //     (points[flag + 1][1] - points[flag - 1][1]) / (points[flag + 1][0] - points[flag - 1][0]) :
+            //     (points[flag][1] - points[flag - 1][1]) / (points[flag][0] - points[flag - 1][0])
+
+            // 修复超过界限的值问题
+            // 2023年6月25日 于南京
+            if (flag < points.length - 1) {
+                if (
+                    (points[flag + 1][1] > points[flag][1] && points[flag - 1][1] > points[flag][1]) ||
+                    (points[flag + 1][1] < points[flag][1] && points[flag - 1][1] < points[flag][1]) ||
+                    points[flag + 1][1] == points[flag][1] ||
+                    points[flag - 1][1] == points[flag][1]
+                ) {
+                    temp = 0
+                } else {
+                    temp = (points[flag + 1][1] - points[flag - 1][1]) / (points[flag + 1][0] - points[flag - 1][0])
+                }
+            } else {
+                temp = (points[flag][1] - points[flag - 1][1]) / (points[flag][0] - points[flag - 1][0])
+            }
+
+            // 求解两个点直接的插值方程
+            // 第一个点的前一个点直接取第一个点
+            // 最后一个点的后一个点直接取最后一个点
+            this.__HS.h[flag - 1] = new Hermite((1 - this.__t) * 0.5).setP(points[flag - 1][0], points[flag - 1][1], points[flag][0], points[flag][1], slope, temp)
+            slope = temp
+        }
+        return this
+
+    }
+
+    // 根据x值返回y值
+    use(x: number) {
+        if (this.__HS) {
+            this.__i = -1
+
+            // 寻找记录x所在位置的区间
+            // 这里就是寻找对应的拟合函数
+            while (this.__i + 1 < this.__HS.x.length && (x > this.__HS.x[this.__i + 1] || (this.__i == -1 && x >= this.__HS.x[this.__i + 1]))) {
+                this.__i += 1
+            }
+
+            // 由于js浮点运算不准确，我们对于越界的情况进行兼容
+
+            if (this.__i < 0) {
+                return this.__HS.h[0].use(this.__HS.x[0])
+            }
+
+            else if (this.__i >= this.__HS.h.length) {
+                return this.__HS.h[this.__HS.h.length - 1].use(this.__HS.x[this.__HS.x.length - 1])
+            }
+
+            return this.__HS.h[this.__i].use(x)
+        } else {
+            throw new Error('You shoud first set the position!')
+        }
+    }
+
+}
+
 export default Cardinal

package/src/interpolation/Hermite.ts

@@ -1,66 +1,66 @@
-import type HermiteType from '../../types/Hermite'
-
-class Hermite implements HermiteType {
-    readonly name: string = 'Hermite'
-
-    private __u: number // 张弛系数
-
-    private __MR: number[]
-    private __a: number
-    private __b: number
-
-    constructor(u: number = 0.5) {
-        this.__u = u
-    }
-
-    /**
-    * 设置点的位置
-    * @param {Number} x1 左边点的位置
-    * @param {Number} y1
-    * @param {Number} x2 右边点的位置
-    * @param {Number} y2
-    * @param {Number} s1 两个点的斜率
-    * @param {Number} s2
-    */
-    setP(x1: number, y1: number, x2: number, y2: number, s1: number, s2: number) {
-        if (x1 < x2) {
-            // 记录原始尺寸
-            this.__a = x1
-            this.__b = x2
-            const p3 = this.__u * s1,
-                p4 = this.__u * s2
-            // 缩放到[0,1]定义域
-            y1 /= (x2 - x1)
-            y2 /= (x2 - x1)
-            // MR是提前计算好的多项式通解矩阵
-            // 为了加速计算
-            // 如上面说的
-            // 统一在[0,1]上计算后再通过缩放和移动恢复
-            // 避免了动态求解矩阵的麻烦
-            this.__MR = [
-                2 * y1 - 2 * y2 + p3 + p4,
-                3 * y2 - 3 * y1 - 2 * p3 - p4,
-                p3,
-                y1
-            ]
-        } else throw new Error('The point x-position should be increamented!')
-        return this
-    }
-
-
-    /**
-     * 根据x值返回y值
-     * @param {Number} x
-     */
-    use(x: number) {
-        if (this.__MR) {
-            const sx = (x - this.__a) / (this.__b - this.__a),
-                sx2 = sx * sx,
-                sx3 = sx * sx2
-            const sResult = sx3 * this.__MR[0] + sx2 * this.__MR[1] + sx * this.__MR[2] + this.__MR[3]
-            return sResult * (this.__b - this.__a)
-        } else throw new Error('You shoud first set the position!')
-    }
-}
-
+import type HermiteType from '../../types/Hermite'
+
+class Hermite implements HermiteType {
+    readonly name: string = 'Hermite'
+
+    private __u: number // 张弛系数
+
+    private __MR: number[]
+    private __a: number
+    private __b: number
+
+    constructor(u: number = 0.5) {
+        this.__u = u
+    }
+
+    /**
+    * 设置点的位置
+    * @param {Number} x1 左边点的位置
+    * @param {Number} y1
+    * @param {Number} x2 右边点的位置
+    * @param {Number} y2
+    * @param {Number} s1 两个点的斜率
+    * @param {Number} s2
+    */
+    setP(x1: number, y1: number, x2: number, y2: number, s1: number, s2: number) {
+        if (x1 < x2) {
+            // 记录原始尺寸
+            this.__a = x1
+            this.__b = x2
+            const p3 = this.__u * s1,
+                p4 = this.__u * s2
+            // 缩放到[0,1]定义域
+            y1 /= (x2 - x1)
+            y2 /= (x2 - x1)
+            // MR是提前计算好的多项式通解矩阵
+            // 为了加速计算
+            // 如上面说的
+            // 统一在[0,1]上计算后再通过缩放和移动恢复
+            // 避免了动态求解矩阵的麻烦
+            this.__MR = [
+                2 * y1 - 2 * y2 + p3 + p4,
+                3 * y2 - 3 * y1 - 2 * p3 - p4,
+                p3,
+                y1
+            ]
+        } else throw new Error('The point x-position should be increamented!')
+        return this
+    }
+
+
+    /**
+     * 根据x值返回y值
+     * @param {Number} x
+     */
+    use(x: number) {
+        if (this.__MR) {
+            const sx = (x - this.__a) / (this.__b - this.__a),
+                sx2 = sx * sx,
+                sx3 = sx * sx2
+            const sResult = sx3 * this.__MR[0] + sx2 * this.__MR[1] + sx * this.__MR[2] + this.__MR[3]
+            return sResult * (this.__b - this.__a)
+        } else throw new Error('You shoud first set the position!')
+    }
+}
+
 export default Hermite

package/src/layout/TreeLayout.ts

@@ -10,7 +10,7 @@ import rotate from '../rotate'
 class TreeLayout extends Tree implements TreeLayoutType {
     readonly name: string = 'TreeLayout'
 
-    private __option: TreeOptionType = {
+    private __option = {
         offsetX: 0,
         offsetY: 0,
         duration: 500,
@@ -25,7 +25,7 @@ class TreeLayout extends Tree implements TreeLayoutType {
 
     private __rback: (tree: TreeResultType) => void
     private __oralTree: any
-    private __preTree: TreeResultType
+    private __preTree: TreeResultType | null
 
     private __noOpens = {}
 
@@ -127,7 +127,7 @@ class TreeLayout extends Tree implements TreeLayoutType {
     }
 
     unbind() {
-        this.__rback = null
+        this.__rback = () => null
         this.__oralTree = null
         this.__preTree = null
         this.__noOpens = {}
@@ -141,12 +141,14 @@ class TreeLayout extends Tree implements TreeLayoutType {
 
         animation((deep) => {
 
-            for (const key in cacheTree.node) {
-                if (newTree.node[key].show || this.__preTree.node[key].show) {
-                    cacheTree.node[key].show = true
+            if (this.__preTree) {
+                for (const key in cacheTree.node) {
+                    if (newTree.node[key].show || this.__preTree.node[key].show) {
+                        cacheTree.node[key].show = true
 
-                    cacheTree.node[key].left = this.__preTree.node[key].left + (newTree.node[key].left - this.__preTree.node[key].left) * deep
-                    cacheTree.node[key].top = this.__preTree.node[key].top + (newTree.node[key].top - this.__preTree.node[key].top) * deep
+                        cacheTree.node[key].left = this.__preTree.node[key].left + (newTree.node[key].left - this.__preTree.node[key].left) * deep
+                        cacheTree.node[key].top = this.__preTree.node[key].top + (newTree.node[key].top - this.__preTree.node[key].top) * deep
+                    }
                 }
             }
             this.__rback(cacheTree)
@@ -159,7 +161,7 @@ class TreeLayout extends Tree implements TreeLayoutType {
     }
 
     closeNode(id: string) {
-        if (!this.__preTree) return
+        if (!this.__preTree) return this
         this.__noOpens[id] = true
 
         this.doUpdate()
@@ -167,7 +169,7 @@ class TreeLayout extends Tree implements TreeLayoutType {
     }
 
     openNode(id: string) {
-        if (!this.__preTree) return
+        if (!this.__preTree) return this
         this.__noOpens[id] = false
 
         this.doUpdate()
@@ -175,7 +177,7 @@ class TreeLayout extends Tree implements TreeLayoutType {
     }
 
     toggleNode(id: string) {
-        if (!this.__preTree) return
+        if (!this.__preTree) return this
         this.__noOpens[id] = !this.__noOpens[id]
 
         this.doUpdate()

package/src/move.ts

@@ -1,8 +1,8 @@
-// 点（x,y）沿着向量（ax,ay）方向移动距离d
-export default function (ax: number, ay: number, d: number, x: number, y: number): [number, number] {
-    const sqrt = Math.sqrt(ax * ax + ay * ay)
-    return [
-        ax * d / sqrt + x,
-        ay * d / sqrt + y
-    ]
+// 点（x,y）沿着向量（ax,ay）方向移动距离d
+export default function (ax: number, ay: number, d: number, x: number, y: number): [number, number] {
+    const sqrt = Math.sqrt(ax * ax + ay * ay)
+    return [
+        ax * d / sqrt + x,
+        ay * d / sqrt + y
+    ]
 }

package/src/resizeObserver.ts

@@ -20,11 +20,11 @@ export default function (el: HTMLElement | null, callback: Function) {
         (el as any)._resize_observer_ = uniqueid
         attrValueToCallback[uniqueid] = callback
 
-        observer.observe(el)
+        observer.observe(el as HTMLElement)
 
         return function () {
             if (observer) {
-                observer.unobserve(el)
+                observer.unobserve(el as HTMLElement)
                 delete attrValueToCallback[(el as any)._resize_observer_]
             }
         }

package/src/rotate.ts

@@ -1,8 +1,8 @@
-// 点（x,y）围绕中心（cx,cy）旋转deg度
-export default function (cx: number, cy: number, deg: number, x: number, y: number): [number, number] {
-    const cos = Math.cos(deg), sin = Math.sin(deg)
-    return [
-        (x - cx) * cos - (y - cy) * sin + cx,
-        (x - cx) * sin + (y - cy) * cos + cy
-    ]
+// 点（x,y）围绕中心（cx,cy）旋转deg度
+export default function (cx: number, cy: number, deg: number, x: number, y: number): [number, number] {
+    const cos = Math.cos(deg), sin = Math.sin(deg)
+    return [
+        (x - cx) * cos - (y - cy) * sin + cx,
+        (x - cx) * sin + (y - cy) * cos + cy
+    ]
 }