push the uni-demo project

uni-demo/node_modules/echarts/extension-src/dataTool/gexf.ts

@@ -0,0 +1,222 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+// @ts-nocheck
+/**
+ * This is a parse of GEXF.
+ *
+ * The spec of GEXF:
+ * https://gephi.org/gexf/1.2draft/gexf-12draft-primer.pdf
+ */
+
+import * as zrUtil from 'zrender/src/core/util';
+
+export function parse(xml) {
+    let doc;
+    if (typeof xml === 'string') {
+        const parser = new DOMParser();
+        doc = parser.parseFromString(xml, 'text/xml');
+    }
+    else {
+        doc = xml;
+    }
+    if (!doc || doc.getElementsByTagName('parsererror').length) {
+        return null;
+    }
+
+    const gexfRoot = getChildByTagName(doc, 'gexf');
+
+    if (!gexfRoot) {
+        return null;
+    }
+
+    const graphRoot = getChildByTagName(gexfRoot, 'graph');
+
+    const attributes = parseAttributes(getChildByTagName(graphRoot, 'attributes'));
+    const attributesMap = {};
+    for (let i = 0; i < attributes.length; i++) {
+        attributesMap[attributes[i].id] = attributes[i];
+    }
+
+    return {
+        nodes: parseNodes(getChildByTagName(graphRoot, 'nodes'), attributesMap),
+        links: parseEdges(getChildByTagName(graphRoot, 'edges'))
+    };
+}
+
+function parseAttributes(parent) {
+    return parent ? zrUtil.map(getChildrenByTagName(parent, 'attribute'), function (attribDom) {
+        return {
+            id: getAttr(attribDom, 'id'),
+            title: getAttr(attribDom, 'title'),
+            type: getAttr(attribDom, 'type')
+        };
+    }) : [];
+}
+
+function parseNodes(parent, attributesMap) {
+    return parent ? zrUtil.map(getChildrenByTagName(parent, 'node'), function (nodeDom) {
+
+        const id = getAttr(nodeDom, 'id');
+        const label = getAttr(nodeDom, 'label');
+
+        const node = {
+            id: id,
+            name: label,
+            itemStyle: {
+                normal: {}
+            }
+        };
+
+        const vizSizeDom = getChildByTagName(nodeDom, 'viz:size');
+        const vizPosDom = getChildByTagName(nodeDom, 'viz:position');
+        const vizColorDom = getChildByTagName(nodeDom, 'viz:color');
+        // let vizShapeDom = getChildByTagName(nodeDom, 'viz:shape');
+
+        const attvaluesDom = getChildByTagName(nodeDom, 'attvalues');
+
+        if (vizSizeDom) {
+            node.symbolSize = parseFloat(getAttr(vizSizeDom, 'value'));
+        }
+        if (vizPosDom) {
+            node.x = parseFloat(getAttr(vizPosDom, 'x'));
+            node.y = parseFloat(getAttr(vizPosDom, 'y'));
+            // z
+        }
+        if (vizColorDom) {
+            node.itemStyle.normal.color = 'rgb(' + [
+                getAttr(vizColorDom, 'r') | 0,
+                getAttr(vizColorDom, 'g') | 0,
+                getAttr(vizColorDom, 'b') | 0
+            ].join(',') + ')';
+        }
+        // if (vizShapeDom) {
+            // node.shape = getAttr(vizShapeDom, 'shape');
+        // }
+        if (attvaluesDom) {
+            const attvalueDomList = getChildrenByTagName(attvaluesDom, 'attvalue');
+
+            node.attributes = {};
+
+            for (let j = 0; j < attvalueDomList.length; j++) {
+                const attvalueDom = attvalueDomList[j];
+                const attId = getAttr(attvalueDom, 'for');
+                let attValue = getAttr(attvalueDom, 'value');
+                const attribute = attributesMap[attId];
+
+                if (attribute) {
+                    switch (attribute.type) {
+                        case 'integer':
+                        case 'long':
+                            attValue = parseInt(attValue, 10);
+                            break;
+                        case 'float':
+                        case 'double':
+                            attValue = parseFloat(attValue);
+                            break;
+                        case 'boolean':
+                            attValue = attValue.toLowerCase() === 'true';
+                            break;
+                        default:
+                    }
+                    node.attributes[attId] = attValue;
+                }
+            }
+        }
+
+        return node;
+    }) : [];
+}
+
+function parseEdges(parent) {
+    return parent ? zrUtil.map(getChildrenByTagName(parent, 'edge'), function (edgeDom) {
+        const id = getAttr(edgeDom, 'id');
+        const label = getAttr(edgeDom, 'label');
+
+        const sourceId = getAttr(edgeDom, 'source');
+        const targetId = getAttr(edgeDom, 'target');
+
+        const edge = {
+            id: id,
+            name: label,
+            source: sourceId,
+            target: targetId,
+            lineStyle: {
+                normal: {}
+            }
+        };
+
+        const lineStyle = edge.lineStyle.normal;
+
+        const vizThicknessDom = getChildByTagName(edgeDom, 'viz:thickness');
+        const vizColorDom = getChildByTagName(edgeDom, 'viz:color');
+        // let vizShapeDom = getChildByTagName(edgeDom, 'viz:shape');
+
+        if (vizThicknessDom) {
+            lineStyle.width = parseFloat(vizThicknessDom.getAttribute('value'));
+        }
+        if (vizColorDom) {
+            lineStyle.color = 'rgb(' + [
+                getAttr(vizColorDom, 'r') | 0,
+                getAttr(vizColorDom, 'g') | 0,
+                getAttr(vizColorDom, 'b') | 0
+            ].join(',') + ')';
+        }
+        // if (vizShapeDom) {
+        //     edge.shape = vizShapeDom.getAttribute('shape');
+        // }
+
+        return edge;
+    }) : [];
+}
+
+function getAttr(el, attrName) {
+    return el.getAttribute(attrName);
+}
+
+function getChildByTagName(parent, tagName) {
+    let node = parent.firstChild;
+
+    while (node) {
+        if (
+            node.nodeType !== 1
+            || node.nodeName.toLowerCase() !== tagName.toLowerCase()
+        ) {
+            node = node.nextSibling;
+        }
+        else {
+            return node;
+        }
+    }
+
+    return null;
+}
+
+function getChildrenByTagName(parent, tagName) {
+    let node = parent.firstChild;
+    const children = [];
+    while (node) {
+        if (node.nodeName.toLowerCase() === tagName.toLowerCase()) {
+            children.push(node);
+        }
+        node = node.nextSibling;
+    }
+
+    return children;
+}

uni-demo/node_modules/echarts/extension-src/dataTool/index.ts

@@ -0,0 +1,42 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+// @ts-nocheck
+import * as echarts from 'echarts';
+import * as gexf from './gexf';
+import prepareBoxplotData from './prepareBoxplotData';
+// import { boxplotTransform } from './boxplotTransform';
+
+export const version = '1.0.0';
+
+export {gexf};
+
+export {prepareBoxplotData};
+// export {boxplotTransform};
+
+// For backward compatibility, where the namespace `dataTool` will
+// be mounted on `echarts` is the extension `dataTool` is imported.
+// But the old version of echarts do not have `dataTool` namespace,
+// so check it before mounting.
+if (echarts.dataTool) {
+    echarts.dataTool.version = version;
+    echarts.dataTool.gexf = gexf;
+    echarts.dataTool.prepareBoxplotData = prepareBoxplotData;
+    // echarts.dataTool.boxplotTransform = boxplotTransform;
+}

uni-demo/node_modules/echarts/extension-src/dataTool/prepareBoxplotData.ts

@@ -0,0 +1,114 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+function asc<T extends number[]>(arr: T): T {
+    arr.sort(function (a, b) {
+        return a - b;
+    });
+    return arr;
+}
+
+function quantile(ascArr: number[], p: number): number {
+    const H = (ascArr.length - 1) * p + 1;
+    const h = Math.floor(H);
+    const v = +ascArr[h - 1];
+    const e = H - h;
+    return e ? v + e * (ascArr[h] - v) : v;
+}
+/**
+ * See:
+ *  <https://en.wikipedia.org/wiki/Box_plot#cite_note-frigge_hoaglin_iglewicz-2>
+ *  <http://stat.ethz.ch/R-manual/R-devel/library/grDevices/html/boxplot.stats.html>
+ *
+ * Helper method for preparing data.
+ *
+ * @param {Array.<number>} rawData like
+ *        [
+ *            [12,232,443], (raw data set for the first box)
+ *            [3843,5545,1232], (raw data set for the second box)
+ *            ...
+ *        ]
+ * @param {Object} [opt]
+ *
+ * @param {(number|string)} [opt.boundIQR=1.5] Data less than min bound is outlier.
+ *      default 1.5, means Q1 - 1.5 * (Q3 - Q1).
+ *      If 'none'/0 passed, min bound will not be used.
+ * @param {(number|string)} [opt.layout='horizontal']
+ *      Box plot layout, can be 'horizontal' or 'vertical'
+ * @return {Object} {
+ *      boxData: Array.<Array.<number>>
+ *      outliers: Array.<Array.<number>>
+ *      axisData: Array.<string>
+ * }
+ */
+export default function (
+    rawData: number[][],
+    opt: {
+        boundIQR?: number | 'none',
+        layout?: 'horizontal' | 'vertical'
+    }
+): {
+    boxData: number[][]
+    outliers: number[][]
+    axisData: string[]
+} {
+    opt = opt || {};
+    const boxData = [];
+    const outliers = [];
+    const axisData: string[] = [];
+    const boundIQR = opt.boundIQR;
+    const useExtreme = boundIQR === 'none' || boundIQR === 0;
+
+    for (let i = 0; i < rawData.length; i++) {
+        axisData.push(i + '');
+        const ascList = asc(rawData[i].slice());
+
+        const Q1 = quantile(ascList, 0.25);
+        const Q2 = quantile(ascList, 0.5);
+        const Q3 = quantile(ascList, 0.75);
+        const min = ascList[0];
+        const max = ascList[ascList.length - 1];
+
+        const bound = (boundIQR == null ? 1.5 : boundIQR as number) * (Q3 - Q1);
+
+        const low = useExtreme
+            ? min
+            : Math.max(min, Q1 - bound);
+        const high = useExtreme
+            ? max
+            : Math.min(max, Q3 + bound);
+
+        boxData.push([low, Q1, Q2, Q3, high]);
+
+        for (let j = 0; j < ascList.length; j++) {
+            const dataItem = ascList[j];
+            if (dataItem < low || dataItem > high) {
+                const outlier = [i, dataItem];
+                opt.layout === 'vertical' && outlier.reverse();
+                outliers.push(outlier);
+            }
+        }
+    }
+    return {
+        boxData: boxData,
+        outliers: outliers,
+        axisData: axisData
+    };
+}