vislite 1.2.0-alpha.7 → 1.2.0

package/src/common/svg/gradient.ts

@@ -1,53 +1,53 @@
-import { initDefs } from './config'
-import { toNode, setAttribute } from "./tool"
-
-let enhanceGradient = function (gradient: SVGElement, gradientId: string) {
-    const enhanceGradient = {
-        "value": function () {
-            return "url(#" + gradientId + ")";
-        },
-        "setColor": function (stop: number, color: string) {
-
-            const stopEl = toNode("stop")
-            gradient.appendChild(stopEl)
-            setAttribute(stopEl, "offset", (stop * 100) + "%")
-            setAttribute(stopEl, "style", "stop-color:" + color + ";")
-
-            return enhanceGradient
-        }
-    }
-    return enhanceGradient
-}
-
-// 线性渐变
-export const linearGradient = function (el: SVGElement, x0: number, y0: number, x1: number, y1: number) {
-
-    const defs = initDefs(el)
-    const gradientId = "vislite-lg-" + new Date().valueOf() + "-" + Math.random()
-
-    const linearGradient = toNode("linearGradient")
-    defs.appendChild(linearGradient)
-    setAttribute(linearGradient, "id", gradientId)
-    setAttribute(linearGradient, "x1", x0 + "%")
-    setAttribute(linearGradient, "y1", y0 + "%")
-    setAttribute(linearGradient, "x2", x1 + "%")
-    setAttribute(linearGradient, "y2", y1 + "%")
-
-    return enhanceGradient(linearGradient, gradientId)
-}
-
-// 环形渐变
-export const radialGradient = function (el: SVGElement, cx: number, cy: number, r: number) {
-
-    const defs = initDefs(el)
-    const gradientId = "vislite-rg-" + new Date().valueOf() + "-" + Math.random()
-
-    const radialGradient = toNode("radialGradient")
-    defs.appendChild(radialGradient)
-    setAttribute(radialGradient, "id", gradientId)
-    setAttribute(radialGradient, "cx", cx + "%")
-    setAttribute(radialGradient, "cy", cy + "%")
-    setAttribute(radialGradient, "r", r + "%")
-
-    return enhanceGradient(radialGradient, gradientId)
-}
+import { initDefs } from './config'
+import { toNode, setAttribute } from "./tool"
+
+let enhanceGradient = function (gradient: SVGElement, gradientId: string) {
+    const enhanceGradient = {
+        "value": function () {
+            return "url(#" + gradientId + ")";
+        },
+        "setColor": function (stop: number, color: string) {
+
+            const stopEl = toNode("stop")
+            gradient.appendChild(stopEl)
+            setAttribute(stopEl, "offset", (stop * 100) + "%")
+            setAttribute(stopEl, "style", "stop-color:" + color + ";")
+
+            return enhanceGradient
+        }
+    }
+    return enhanceGradient
+}
+
+// 线性渐变
+export const linearGradient = function (el: SVGElement, x0: number, y0: number, x1: number, y1: number) {
+
+    const defs = initDefs(el)
+    const gradientId = "vislite-lg-" + new Date().valueOf() + "-" + Math.random()
+
+    const linearGradient = toNode("linearGradient")
+    defs.appendChild(linearGradient)
+    setAttribute(linearGradient, "id", gradientId)
+    setAttribute(linearGradient, "x1", x0 + "%")
+    setAttribute(linearGradient, "y1", y0 + "%")
+    setAttribute(linearGradient, "x2", x1 + "%")
+    setAttribute(linearGradient, "y2", y1 + "%")
+
+    return enhanceGradient(linearGradient, gradientId)
+}
+
+// 环形渐变
+export const radialGradient = function (el: SVGElement, cx: number, cy: number, r: number) {
+
+    const defs = initDefs(el)
+    const gradientId = "vislite-rg-" + new Date().valueOf() + "-" + Math.random()
+
+    const radialGradient = toNode("radialGradient")
+    defs.appendChild(radialGradient)
+    setAttribute(radialGradient, "id", gradientId)
+    setAttribute(radialGradient, "cx", cx + "%")
+    setAttribute(radialGradient, "cy", cy + "%")
+    setAttribute(radialGradient, "r", r + "%")
+
+    return enhanceGradient(radialGradient, gradientId)
+}

package/src/common/svg/index.ts

@@ -1,39 +1,16 @@
 import type { default as SVGConfigType, svgElType, svgBoardType } from "../../../types/SVGConfig"
-import type { arcCapType, textAlignType, textBaselineType, lineCapType, lineJoinType } from "../../../types/painterConfig"
 
 import { initText, initCircle, initPath, initRect, initArc } from "./config"
 import { toNode, setAttribute, getAttribute, full, fill, stroke } from "./tool"
 import rotate from "../../rotate"
 import { linearGradient, radialGradient } from "./gradient"
+import defaultFactory from "./default"
 
 class SVG {
     readonly name: string = "SVG"
 
     // 用于记录配置
-    private __config = {
-
-        // 颜色
-        fillStyle: "#000",
-        strokeStyle: "#000",
-
-        // 文字对齐方式
-        textAlign: <textAlignType>"left",
-        textBaseline: <textBaselineType>"middle",
-
-        // 文字
-        "fontSize": 16,
-        "fontFamily": "sans-serif",
-
-        // arc二端闭合方式['butt':直线闭合,'round':圆帽闭合]
-        "arcStartCap": <arcCapType>"butt",
-        "arcEndCap": <arcCapType>"butt",
-
-        // 线条
-        lineDash: [],
-        lineWidth: 1,
-        lineCap: <lineCapType>"butt",
-        lineJoin: <lineJoinType>"miter"
-    }
+    private __config = defaultFactory()
 
     // 作用的节点
     private __useEl: SVGElement
@@ -53,12 +30,17 @@ class SVG {
             return this.__config[params]
         } else {
             for (const key in params) {
-                this.__config[key] = params[key]
+                (this.__config as any)[key] = (params as any)[key]
             }
         }
         return this
     }
 
+    reset() {
+        this.config(defaultFactory())
+        return this
+    }
+
     /**
      * 基础方法
      * ---------------------------------

package/src/common/tree/index.ts

@@ -1,26 +1,26 @@
-import type TreeConfigType from '../../../types/TreeConfig'
-import type { TreeResultType } from '../../../types/Tree'
-
-import toPlainTree from './toPlainTree'
-import { initOption } from '../option'
-
-class Tree {
-    readonly name: string = 'Tree'
-
-    private __config: TreeConfigType
-
-    constructor(config: TreeConfigType = {}) {
-        this.__config = initOption(config, {
-            root: (initTree: any) => initTree,
-            children: (parentTree: any) => parentTree.children,
-            id: (treedata: any) => treedata.name
-        })
-    }
-
-    use(initTree: any, noOpens = {}): TreeResultType {
-        return toPlainTree(initTree, this.__config, noOpens)
-    }
-
-}
-
+import type TreeConfigType from '../../../types/TreeConfig'
+import type { TreeResultType } from '../../../types/Tree'
+
+import toPlainTree from './toPlainTree'
+import { initOption } from '../option'
+
+class Tree {
+    readonly name: string = 'Tree'
+
+    private __config: TreeConfigType
+
+    constructor(config: TreeConfigType = {}) {
+        this.__config = initOption(config, {
+            root: (initTree: any) => initTree,
+            children: (parentTree: any) => parentTree.children,
+            id: (treedata: any) => treedata.name
+        })
+    }
+
+    use(initTree: any, noOpens = {}): TreeResultType {
+        return toPlainTree(initTree, this.__config, noOpens)
+    }
+
+}
+
 export default Tree

package/src/common/tree/toInnerTree.ts

@@ -1,60 +1,60 @@
-import type { default as TreeConfigType, rootType, childrenType, idType } from '../../../types/TreeConfig'
-
-/**
- * 根据配置的层次关系（配置的id,child,root）把原始数据变成内部结构，方便后期位置计算
- *
- * tempTree[id] = {
- *  "data": 原始数据,
- *  "pid": 父亲ID,
- *  "id": 唯一标识ID,
- *  "show": boolean,
- *  "isOpen": boolean,
- *  "children": [cid1、cid2、...]
- * }
- */
-export default (initTree: any, config: TreeConfigType) => {
-    const tempTree: {
-        [key: string]: any
-    } = {}
-
-    // 根结点
-    const temp = (config.root as rootType)(initTree)
-    let id: number | string, rid: number | string
-    id = rid = (config.id as idType)(temp)
-    tempTree[id] = {
-        "data": temp,
-        "pid": null,
-        "id": id,
-        "isOpen": true,
-        "show": true,
-        "children": []
-    }
-
-    let num: number = 1
-
-        // 根据传递的原始数据，生成内部统一结构
-        ; (function createTree(pdata: any, pid: number | string) {
-            const children = (config.children as childrenType)(pdata, initTree)
-            num += children ? children.length : 0
-            for (let flag = 0; children && flag < children.length; flag++) {
-                id = (config.id as idType)(children[flag])
-                tempTree[pid].children.push(id);
-                tempTree[id] = {
-                    "data": children[flag],
-                    "pid": pid,
-                    "id": id,
-                    "isOpen": true,
-                    "show": true,
-                    "children": []
-                }
-                createTree(children[flag], id)
-            }
-        })(temp, id)
-
-    return {
-        rid,
-        value: tempTree,
-        num
-    }
-
+import type { default as TreeConfigType, rootType, childrenType, idType } from '../../../types/TreeConfig'
+
+/**
+ * 根据配置的层次关系（配置的id,child,root）把原始数据变成内部结构，方便后期位置计算
+ *
+ * tempTree[id] = {
+ *  "data": 原始数据,
+ *  "pid": 父亲ID,
+ *  "id": 唯一标识ID,
+ *  "show": boolean,
+ *  "isOpen": boolean,
+ *  "children": [cid1、cid2、...]
+ * }
+ */
+export default (initTree: any, config: TreeConfigType) => {
+    const tempTree: {
+        [key: string]: any
+    } = {}
+
+    // 根结点
+    const temp = (config.root as rootType)(initTree)
+    let id: number | string, rid: number | string
+    id = rid = (config.id as idType)(temp)
+    tempTree[id] = {
+        "data": temp,
+        "pid": null,
+        "id": id,
+        "isOpen": true,
+        "show": true,
+        "children": []
+    }
+
+    let num: number = 1
+
+        // 根据传递的原始数据，生成内部统一结构
+        ; (function createTree(pdata: any, pid: number | string) {
+            const children = (config.children as childrenType)(pdata, initTree)
+            num += children ? children.length : 0
+            for (let flag = 0; children && flag < children.length; flag++) {
+                id = (config.id as idType)(children[flag])
+                tempTree[pid].children.push(id);
+                tempTree[id] = {
+                    "data": children[flag],
+                    "pid": pid,
+                    "id": id,
+                    "isOpen": true,
+                    "show": true,
+                    "children": []
+                }
+                createTree(children[flag], id)
+            }
+        })(temp, id)
+
+    return {
+        rid,
+        value: tempTree,
+        num
+    }
+
 }

package/src/common/tree/toPlainTree.ts

@@ -1,133 +1,133 @@
-import type TreeConfigType from '../../../types/TreeConfig'
-
-import toInnerTree from './toInnerTree'
-
-// 可以传递任意格式的树原始数据
-// 只要配置对应的解析方法即可
-export default function (initTree: any, config: TreeConfigType, noOpens: {}) {
-    const treeData = toInnerTree(initTree, config)
-
-    const alltreedata = treeData.value // 维护的树
-    const rootid = treeData.rid // 根结点ID
-
-    if (treeData.num == 1) {
-        alltreedata[rootid].left = 0.5
-        alltreedata[rootid].top = 0.5
-        alltreedata[rootid].show = true
-        return {
-            deep: 1,
-            node: alltreedata,
-            root: rootid,
-            size: 1
-        }
-    } else {
-
-        const beforeDis: Array<number> = []
-        let size = 0, maxDeep = 0
-
-        if (noOpens[rootid]) {
-            alltreedata[rootid].left = 0.5
-            alltreedata[rootid].top = 0.5
-            alltreedata[rootid].show = true
-
-            size = 1
-        } else {
-            ; (function positionCalc(pNode, deep) {
-
-                if (deep > maxDeep) maxDeep = deep
-
-                let flag: number = 0
-                if (!noOpens[pNode.id]) {
-
-                    for (flag = 0; flag < pNode.children.length; flag++)
-
-                        // 因为全部的子结点的位置确定了，父结点的y位置就是子结点的中间位置
-                        // 因此有子结点的，先计算子结点
-                        positionCalc(alltreedata[pNode.children[flag]], deep + 1)
-
-                }
-
-                // left的位置比较简单，deep从0开始编号
-                // 比如deep=0，第一层，left=0+0.5=0.5，也就是根结点
-                alltreedata[pNode.id].left = deep + 0.5
-                if (flag == 0) {
-
-                    // beforeDis是一个数组，用以记录每一层此刻top下边缘（每一层是从上到下）
-                    // 比如一层的第一个，top值最小可以取top=0.5
-                    // 为了方便计算，beforeDis[deep] == undefined的时候表示现在准备计算的是这层的第一个结点
-                    // 因此设置最低上边缘为-0.5
-                    if (beforeDis[deep] == void 0) beforeDis[deep] = -0.5
-                    // 父边缘同意的进行初始化
-                    if (beforeDis[deep - 1] == void 0) beforeDis[deep - 1] = -0.5
-
-                    // 添加的新结点top值第一种求法：本层上边缘+1（比如上边缘是-0.5，那么top最小是top=-0.5+1=0.5）
-                    alltreedata[pNode.id].top = beforeDis[deep] + 1
-
-                    const pTop = beforeDis[deep] + 1 + (alltreedata[pNode.pid].children.length - 1) * 0.5
-                    // 计算的原则是：如果第一种可行，选择第一种，否则必须选择第二种
-                    // 判断第一种是否可行的方法就是：如果第一种计算后确定的孩子上边缘不对导致孩子和孩子的前兄弟重合就是可行的
-                    if (pTop - 1 < beforeDis[deep - 1])
-                        // 必须保证父亲结点和父亲的前一个兄弟保存1的距离，至少
-                        // 添加的新结点top值的第二种求法：根据孩子取孩子结点的中心top
-                        alltreedata[pNode.id].top = beforeDis[deep - 1] + 1 - (alltreedata[pNode.pid].children.length - 1) * 0.5
-
-                } else {
-
-                    // 此刻flag!=0
-                    // 意味着结点有孩子，那么问题就解决了，直接取孩子的中间即可
-                    // 其实，flag==0的分支计算的就是孩子，是没有孩子的叶结点，那是关键
-                    alltreedata[pNode.id].top = (alltreedata[pNode.children[0]].top + alltreedata[pNode.children[flag - 1]].top) * 0.5
-                }
-
-                // 因为计算孩子的时候
-                // 无法掌握父辈兄弟的情况
-                // 可能会出现父亲和兄弟重叠问题
-                if (alltreedata[pNode.id].top <= beforeDis[deep]) {
-                    const needUp = beforeDis[deep] + 1 - alltreedata[pNode.id].top
-                        (function doUp(_pid: number | string, _deep: number) {
-                            alltreedata[_pid].top += needUp;
-                            if (beforeDis[_deep] < alltreedata[_pid].top) beforeDis[_deep] = alltreedata[_pid].top
-
-                            for (let _flag = 0; _flag < alltreedata[_pid].children.length; _flag++) {
-                                doUp(alltreedata[_pid].children[_flag], _deep + 1)
-                            }
-                        })(pNode.id, deep)
-                }
-
-                // 计算好一个结点后，需要更新此刻该层的上边缘
-                beforeDis[deep] = alltreedata[pNode.id].top
-
-                // size在每次计算一个结点后更新，是为了最终绘图的时候知道树有多宽（此处应该叫高）
-                if (alltreedata[pNode.id].top + 0.5 > size) size = alltreedata[pNode.id].top + 0.5
-
-            })(alltreedata[rootid], 0)
-
-        }
-        // 对于不显示的，需要标记一下
-        for (const key in noOpens) {
-            if (noOpens[key]) {
-                alltreedata[key].isOpen = false
-                    ; (function updateHidden(pid, left, top) {
-                        for (let index = 0; index < alltreedata[pid].children.length; index++) {
-                            alltreedata[alltreedata[pid].children[index]].left = left
-                            alltreedata[alltreedata[pid].children[index]].top = top
-                            alltreedata[alltreedata[pid].children[index]].show = false
-
-                            updateHidden(alltreedata[pid].children[index], left, top)
-                        }
-                    })(key, alltreedata[key].left, alltreedata[key].top)
-            }
-        }
-
-        // 传递的参数分别表示：记录了位置信息的树结点集合、根结点ID和树的宽
-        return {
-            "node": alltreedata,
-            "root": rootid,
-            "size": size,
-            "deep": maxDeep + 1
-        }
-
-    }
-
-
+import type TreeConfigType from '../../../types/TreeConfig'
+
+import toInnerTree from './toInnerTree'
+
+// 可以传递任意格式的树原始数据
+// 只要配置对应的解析方法即可
+export default function (initTree: any, config: TreeConfigType, noOpens: {}) {
+    const treeData = toInnerTree(initTree, config)
+
+    const alltreedata = treeData.value // 维护的树
+    const rootid = treeData.rid // 根结点ID
+
+    if (treeData.num == 1) {
+        alltreedata[rootid].left = 0.5
+        alltreedata[rootid].top = 0.5
+        alltreedata[rootid].show = true
+        return {
+            deep: 1,
+            node: alltreedata,
+            root: rootid,
+            size: 1
+        }
+    } else {
+
+        const beforeDis: Array<number> = []
+        let size = 0, maxDeep = 0
+
+        if (noOpens[rootid]) {
+            alltreedata[rootid].left = 0.5
+            alltreedata[rootid].top = 0.5
+            alltreedata[rootid].show = true
+
+            size = 1
+        } else {
+            ; (function positionCalc(pNode, deep) {
+
+                if (deep > maxDeep) maxDeep = deep
+
+                let flag: number = 0
+                if (!noOpens[pNode.id]) {
+
+                    for (flag = 0; flag < pNode.children.length; flag++)
+
+                        // 因为全部的子结点的位置确定了，父结点的y位置就是子结点的中间位置
+                        // 因此有子结点的，先计算子结点
+                        positionCalc(alltreedata[pNode.children[flag]], deep + 1)
+
+                }
+
+                // left的位置比较简单，deep从0开始编号
+                // 比如deep=0，第一层，left=0+0.5=0.5，也就是根结点
+                alltreedata[pNode.id].left = deep + 0.5
+                if (flag == 0) {
+
+                    // beforeDis是一个数组，用以记录每一层此刻top下边缘（每一层是从上到下）
+                    // 比如一层的第一个，top值最小可以取top=0.5
+                    // 为了方便计算，beforeDis[deep] == undefined的时候表示现在准备计算的是这层的第一个结点
+                    // 因此设置最低上边缘为-0.5
+                    if (beforeDis[deep] == void 0) beforeDis[deep] = -0.5
+                    // 父边缘同意的进行初始化
+                    if (beforeDis[deep - 1] == void 0) beforeDis[deep - 1] = -0.5
+
+                    // 添加的新结点top值第一种求法：本层上边缘+1（比如上边缘是-0.5，那么top最小是top=-0.5+1=0.5）
+                    alltreedata[pNode.id].top = beforeDis[deep] + 1
+
+                    const pTop = beforeDis[deep] + 1 + (alltreedata[pNode.pid].children.length - 1) * 0.5
+                    // 计算的原则是：如果第一种可行，选择第一种，否则必须选择第二种
+                    // 判断第一种是否可行的方法就是：如果第一种计算后确定的孩子上边缘不对导致孩子和孩子的前兄弟重合就是可行的
+                    if (pTop - 1 < beforeDis[deep - 1])
+                        // 必须保证父亲结点和父亲的前一个兄弟保存1的距离，至少
+                        // 添加的新结点top值的第二种求法：根据孩子取孩子结点的中心top
+                        alltreedata[pNode.id].top = beforeDis[deep - 1] + 1 - (alltreedata[pNode.pid].children.length - 1) * 0.5
+
+                } else {
+
+                    // 此刻flag!=0
+                    // 意味着结点有孩子，那么问题就解决了，直接取孩子的中间即可
+                    // 其实，flag==0的分支计算的就是孩子，是没有孩子的叶结点，那是关键
+                    alltreedata[pNode.id].top = (alltreedata[pNode.children[0]].top + alltreedata[pNode.children[flag - 1]].top) * 0.5
+                }
+
+                // 因为计算孩子的时候
+                // 无法掌握父辈兄弟的情况
+                // 可能会出现父亲和兄弟重叠问题
+                if (alltreedata[pNode.id].top <= beforeDis[deep]) {
+                    const needUp = beforeDis[deep] + 1 - alltreedata[pNode.id].top
+                        (function doUp(_pid: number | string, _deep: number) {
+                            alltreedata[_pid].top += needUp;
+                            if (beforeDis[_deep] < alltreedata[_pid].top) beforeDis[_deep] = alltreedata[_pid].top
+
+                            for (let _flag = 0; _flag < alltreedata[_pid].children.length; _flag++) {
+                                doUp(alltreedata[_pid].children[_flag], _deep + 1)
+                            }
+                        })(pNode.id, deep)
+                }
+
+                // 计算好一个结点后，需要更新此刻该层的上边缘
+                beforeDis[deep] = alltreedata[pNode.id].top
+
+                // size在每次计算一个结点后更新，是为了最终绘图的时候知道树有多宽（此处应该叫高）
+                if (alltreedata[pNode.id].top + 0.5 > size) size = alltreedata[pNode.id].top + 0.5
+
+            })(alltreedata[rootid], 0)
+
+        }
+        // 对于不显示的，需要标记一下
+        for (const key in noOpens) {
+            if (noOpens[key]) {
+                alltreedata[key].isOpen = false
+                    ; (function updateHidden(pid, left, top) {
+                        for (let index = 0; index < alltreedata[pid].children.length; index++) {
+                            alltreedata[alltreedata[pid].children[index]].left = left
+                            alltreedata[alltreedata[pid].children[index]].top = top
+                            alltreedata[alltreedata[pid].children[index]].show = false
+
+                            updateHidden(alltreedata[pid].children[index], left, top)
+                        }
+                    })(key, alltreedata[key].left, alltreedata[key].top)
+            }
+        }
+
+        // 传递的参数分别表示：记录了位置信息的树结点集合、根结点ID和树的宽
+        return {
+            "node": alltreedata,
+            "root": rootid,
+            "size": size,
+            "deep": maxDeep + 1
+        }
+
+    }
+
+
 }