You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@echarts.apache.org by sh...@apache.org on 2022/01/20 15:33:04 UTC

[echarts-examples] branch dev updated: update more case to ts

This is an automated email from the ASF dual-hosted git repository.

shenyi pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/echarts-examples.git


The following commit(s) were added to refs/heads/dev by this push:
     new f8ce805  update more case to ts
f8ce805 is described below

commit f8ce805d615796e74a4573503ce8d680c151b646
Author: pissang <bm...@gmail.com>
AuthorDate: Thu Jan 20 23:31:15 2022 +0800

    update more case to ts
---
 public/examples/ts/graphic-stroke-animation.ts |   8 +-
 public/examples/ts/heatmap-large-piecewise.js  | 449 -------------------------
 public/examples/ts/heatmap-large-piecewise.ts  | 202 +++++++++++
 public/examples/ts/heatmap-large.js            | 441 ------------------------
 public/examples/ts/heatmap-large.ts            | 192 +++++++++++
 public/examples/ts/line-draggable.ts           |   2 +-
 public/examples/ts/line-graphic.ts             |   2 +-
 7 files changed, 400 insertions(+), 896 deletions(-)

diff --git a/public/examples/ts/graphic-stroke-animation.ts b/public/examples/ts/graphic-stroke-animation.ts
index d1be37f..5464f8f 100644
--- a/public/examples/ts/graphic-stroke-animation.ts
+++ b/public/examples/ts/graphic-stroke-animation.ts
@@ -1,9 +1,9 @@
 /*
 title: Stroke Animation
-category: 'graphic'
-titleCN: 描边动画
-difficulty: 2
-videoStart: 500
+category: graphic
+titleCN: 关键帧描边动画
+difficulty: 5
+videoStart: 1000
 videoEnd: 3000
 */
 
diff --git a/public/examples/ts/heatmap-large-piecewise.js b/public/examples/ts/heatmap-large-piecewise.js
deleted file mode 100644
index 6a3d394..0000000
--- a/public/examples/ts/heatmap-large-piecewise.js
+++ /dev/null
@@ -1,449 +0,0 @@
-/*
-title: Heatmap - Discrete Mapping of Color
-category: heatmap
-titleCN: 热力图 - 颜色的离散映射
-difficulty: 2
-*/
-
-var noise = getNoiseHelper();
-var xData = [];
-var yData = [];
-noise.seed(Math.random());
-function generateData(theta, min, max) {
-  var data = [];
-  for (var i = 0; i <= 200; i++) {
-    for (var j = 0; j <= 100; j++) {
-      // var x = (max - min) * i / 200 + min;
-      // var y = (max - min) * j / 100 + min;
-      data.push([i, j, noise.perlin2(i / 40, j / 20) + 0.5]);
-      // data.push([i, j, normalDist(theta, x) * normalDist(theta, y)]);
-    }
-    xData.push(i);
-  }
-  for (var j = 0; j < 100; j++) {
-    yData.push(j);
-  }
-  return data;
-}
-var data = generateData(2, -5, 5);
-
-option = {
-  tooltip: {},
-  grid: {
-    right: 140,
-    left: 40
-  },
-  xAxis: {
-    type: 'category',
-    data: xData
-  },
-  yAxis: {
-    type: 'category',
-    data: yData
-  },
-  visualMap: {
-    type: 'piecewise',
-    min: 0,
-    max: 1,
-    left: 'right',
-    top: 'center',
-    calculable: true,
-    realtime: false,
-    splitNumber: 8,
-    inRange: {
-      color: [
-        '#313695',
-        '#4575b4',
-        '#74add1',
-        '#abd9e9',
-        '#e0f3f8',
-        '#ffffbf',
-        '#fee090',
-        '#fdae61',
-        '#f46d43',
-        '#d73027',
-        '#a50026'
-      ]
-    }
-  },
-  series: [
-    {
-      name: 'Gaussian',
-      type: 'heatmap',
-      data: data,
-      emphasis: {
-        itemStyle: {
-          borderColor: '#333',
-          borderWidth: 1
-        }
-      },
-      progressive: 1000,
-      animation: false
-    }
-  ]
-};
-
-///////////////////////////////////////////////////////////////////////////
-// Simplex and perlin noise helper from https://github.com/josephg/noisejs
-///////////////////////////////////////////////////////////////////////////
-function getNoiseHelper(global) {
-  var module = {};
-
-  function Grad(x, y, z) {
-    this.x = x;
-    this.y = y;
-    this.z = z;
-  }
-
-  Grad.prototype.dot2 = function (x, y) {
-    return this.x * x + this.y * y;
-  };
-
-  Grad.prototype.dot3 = function (x, y, z) {
-    return this.x * x + this.y * y + this.z * z;
-  };
-
-  var grad3 = [
-    new Grad(1, 1, 0),
-    new Grad(-1, 1, 0),
-    new Grad(1, -1, 0),
-    new Grad(-1, -1, 0),
-    new Grad(1, 0, 1),
-    new Grad(-1, 0, 1),
-    new Grad(1, 0, -1),
-    new Grad(-1, 0, -1),
-    new Grad(0, 1, 1),
-    new Grad(0, -1, 1),
-    new Grad(0, 1, -1),
-    new Grad(0, -1, -1)
-  ];
-
-  var p = [
-    151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140,
-    36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120,
-    234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
-    88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
-    134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133,
-    230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161,
-    1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130,
-    116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250,
-    124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227,
-    47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44,
-    154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98,
-    108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34,
-    242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14,
-    239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121,
-    50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243,
-    141, 128, 195, 78, 66, 215, 61, 156, 180
-  ];
-  // To remove the need for index wrapping, double the permutation table length
-  var perm = new Array(512);
-  var gradP = new Array(512);
-
-  // This isn't a very good seeding function, but it works ok. It supports 2^16
-  // different seed values. Write something better if you need more seeds.
-  module.seed = function (seed) {
-    if (seed > 0 && seed < 1) {
-      // Scale the seed out
-      seed *= 65536;
-    }
-
-    seed = Math.floor(seed);
-    if (seed < 256) {
-      seed |= seed << 8;
-    }
-
-    for (var i = 0; i < 256; i++) {
-      var v;
-      if (i & 1) {
-        v = p[i] ^ (seed & 255);
-      } else {
-        v = p[i] ^ ((seed >> 8) & 255);
-      }
-
-      perm[i] = perm[i + 256] = v;
-      gradP[i] = gradP[i + 256] = grad3[v % 12];
-    }
-  };
-
-  module.seed(0);
-
-  /*
-  for(var i=0; i<256; i++) {
-    perm[i] = perm[i + 256] = p[i];
-    gradP[i] = gradP[i + 256] = grad3[perm[i] % 12];
-  }*/
-
-  // Skewing and unskewing factors for 2, 3, and 4 dimensions
-  var F2 = 0.5 * (Math.sqrt(3) - 1);
-  var G2 = (3 - Math.sqrt(3)) / 6;
-
-  var F3 = 1 / 3;
-  var G3 = 1 / 6;
-
-  // 2D simplex noise
-  module.simplex2 = function (xin, yin) {
-    var n0, n1, n2; // Noise contributions from the three corners
-    // Skew the input space to determine which simplex cell we're in
-    var s = (xin + yin) * F2; // Hairy factor for 2D
-    var i = Math.floor(xin + s);
-    var j = Math.floor(yin + s);
-    var t = (i + j) * G2;
-    var x0 = xin - i + t; // The x,y distances from the cell origin, unskewed.
-    var y0 = yin - j + t;
-    // For the 2D case, the simplex shape is an equilateral triangle.
-    // Determine which simplex we are in.
-    var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
-    if (x0 > y0) {
-      // lower triangle, XY order: (0,0)->(1,0)->(1,1)
-      i1 = 1;
-      j1 = 0;
-    } else {
-      // upper triangle, YX order: (0,0)->(0,1)->(1,1)
-      i1 = 0;
-      j1 = 1;
-    }
-    // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
-    // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
-    // c = (3-sqrt(3))/6
-    var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
-    var y1 = y0 - j1 + G2;
-    var x2 = x0 - 1 + 2 * G2; // Offsets for last corner in (x,y) unskewed coords
-    var y2 = y0 - 1 + 2 * G2;
-    // Work out the hashed gradient indices of the three simplex corners
-    i &= 255;
-    j &= 255;
-    var gi0 = gradP[i + perm[j]];
-    var gi1 = gradP[i + i1 + perm[j + j1]];
-    var gi2 = gradP[i + 1 + perm[j + 1]];
-    // Calculate the contribution from the three corners
-    var t0 = 0.5 - x0 * x0 - y0 * y0;
-    if (t0 < 0) {
-      n0 = 0;
-    } else {
-      t0 *= t0;
-      n0 = t0 * t0 * gi0.dot2(x0, y0); // (x,y) of grad3 used for 2D gradient
-    }
-    var t1 = 0.5 - x1 * x1 - y1 * y1;
-    if (t1 < 0) {
-      n1 = 0;
-    } else {
-      t1 *= t1;
-      n1 = t1 * t1 * gi1.dot2(x1, y1);
-    }
-    var t2 = 0.5 - x2 * x2 - y2 * y2;
-    if (t2 < 0) {
-      n2 = 0;
-    } else {
-      t2 *= t2;
-      n2 = t2 * t2 * gi2.dot2(x2, y2);
-    }
-    // Add contributions from each corner to get the final noise value.
-    // The result is scaled to return values in the interval [-1,1].
-    return 70 * (n0 + n1 + n2);
-  };
-
-  // 3D simplex noise
-  module.simplex3 = function (xin, yin, zin) {
-    var n0, n1, n2, n3; // Noise contributions from the four corners
-
-    // Skew the input space to determine which simplex cell we're in
-    var s = (xin + yin + zin) * F3; // Hairy factor for 2D
-    var i = Math.floor(xin + s);
-    var j = Math.floor(yin + s);
-    var k = Math.floor(zin + s);
-
-    var t = (i + j + k) * G3;
-    var x0 = xin - i + t; // The x,y distances from the cell origin, unskewed.
-    var y0 = yin - j + t;
-    var z0 = zin - k + t;
-
-    // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
-    // Determine which simplex we are in.
-    var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
-    var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
-    if (x0 >= y0) {
-      if (y0 >= z0) {
-        i1 = 1;
-        j1 = 0;
-        k1 = 0;
-        i2 = 1;
-        j2 = 1;
-        k2 = 0;
-      } else if (x0 >= z0) {
-        i1 = 1;
-        j1 = 0;
-        k1 = 0;
-        i2 = 1;
-        j2 = 0;
-        k2 = 1;
-      } else {
-        i1 = 0;
-        j1 = 0;
-        k1 = 1;
-        i2 = 1;
-        j2 = 0;
-        k2 = 1;
-      }
-    } else {
-      if (y0 < z0) {
-        i1 = 0;
-        j1 = 0;
-        k1 = 1;
-        i2 = 0;
-        j2 = 1;
-        k2 = 1;
-      } else if (x0 < z0) {
-        i1 = 0;
-        j1 = 1;
-        k1 = 0;
-        i2 = 0;
-        j2 = 1;
-        k2 = 1;
-      } else {
-        i1 = 0;
-        j1 = 1;
-        k1 = 0;
-        i2 = 1;
-        j2 = 1;
-        k2 = 0;
-      }
-    }
-    // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
-    // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
-    // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
-    // c = 1/6.
-    var x1 = x0 - i1 + G3; // Offsets for second corner
-    var y1 = y0 - j1 + G3;
-    var z1 = z0 - k1 + G3;
-
-    var x2 = x0 - i2 + 2 * G3; // Offsets for third corner
-    var y2 = y0 - j2 + 2 * G3;
-    var z2 = z0 - k2 + 2 * G3;
-
-    var x3 = x0 - 1 + 3 * G3; // Offsets for fourth corner
-    var y3 = y0 - 1 + 3 * G3;
-    var z3 = z0 - 1 + 3 * G3;
-
-    // Work out the hashed gradient indices of the four simplex corners
-    i &= 255;
-    j &= 255;
-    k &= 255;
-    var gi0 = gradP[i + perm[j + perm[k]]];
-    var gi1 = gradP[i + i1 + perm[j + j1 + perm[k + k1]]];
-    var gi2 = gradP[i + i2 + perm[j + j2 + perm[k + k2]]];
-    var gi3 = gradP[i + 1 + perm[j + 1 + perm[k + 1]]];
-
-    // Calculate the contribution from the four corners
-    var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
-    if (t0 < 0) {
-      n0 = 0;
-    } else {
-      t0 *= t0;
-      n0 = t0 * t0 * gi0.dot3(x0, y0, z0); // (x,y) of grad3 used for 2D gradient
-    }
-    var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
-    if (t1 < 0) {
-      n1 = 0;
-    } else {
-      t1 *= t1;
-      n1 = t1 * t1 * gi1.dot3(x1, y1, z1);
-    }
-    var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
-    if (t2 < 0) {
-      n2 = 0;
-    } else {
-      t2 *= t2;
-      n2 = t2 * t2 * gi2.dot3(x2, y2, z2);
-    }
-    var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
-    if (t3 < 0) {
-      n3 = 0;
-    } else {
-      t3 *= t3;
-      n3 = t3 * t3 * gi3.dot3(x3, y3, z3);
-    }
-    // Add contributions from each corner to get the final noise value.
-    // The result is scaled to return values in the interval [-1,1].
-    return 32 * (n0 + n1 + n2 + n3);
-  };
-
-  // ##### Perlin noise stuff
-
-  function fade(t) {
-    return t * t * t * (t * (t * 6 - 15) + 10);
-  }
-
-  function lerp(a, b, t) {
-    return (1 - t) * a + t * b;
-  }
-
-  // 2D Perlin Noise
-  module.perlin2 = function (x, y) {
-    // Find unit grid cell containing point
-    var X = Math.floor(x),
-      Y = Math.floor(y);
-    // Get relative xy coordinates of point within that cell
-    x = x - X;
-    y = y - Y;
-    // Wrap the integer cells at 255 (smaller integer period can be introduced here)
-    X = X & 255;
-    Y = Y & 255;
-
-    // Calculate noise contributions from each of the four corners
-    var n00 = gradP[X + perm[Y]].dot2(x, y);
-    var n01 = gradP[X + perm[Y + 1]].dot2(x, y - 1);
-    var n10 = gradP[X + 1 + perm[Y]].dot2(x - 1, y);
-    var n11 = gradP[X + 1 + perm[Y + 1]].dot2(x - 1, y - 1);
-
-    // Compute the fade curve value for x
-    var u = fade(x);
-
-    // Interpolate the four results
-    return lerp(lerp(n00, n10, u), lerp(n01, n11, u), fade(y));
-  };
-
-  // 3D Perlin Noise
-  module.perlin3 = function (x, y, z) {
-    // Find unit grid cell containing point
-    var X = Math.floor(x),
-      Y = Math.floor(y),
-      Z = Math.floor(z);
-    // Get relative xyz coordinates of point within that cell
-    x = x - X;
-    y = y - Y;
-    z = z - Z;
-    // Wrap the integer cells at 255 (smaller integer period can be introduced here)
-    X = X & 255;
-    Y = Y & 255;
-    Z = Z & 255;
-
-    // Calculate noise contributions from each of the eight corners
-    var n000 = gradP[X + perm[Y + perm[Z]]].dot3(x, y, z);
-    var n001 = gradP[X + perm[Y + perm[Z + 1]]].dot3(x, y, z - 1);
-    var n010 = gradP[X + perm[Y + 1 + perm[Z]]].dot3(x, y - 1, z);
-    var n011 = gradP[X + perm[Y + 1 + perm[Z + 1]]].dot3(x, y - 1, z - 1);
-    var n100 = gradP[X + 1 + perm[Y + perm[Z]]].dot3(x - 1, y, z);
-    var n101 = gradP[X + 1 + perm[Y + perm[Z + 1]]].dot3(x - 1, y, z - 1);
-    var n110 = gradP[X + 1 + perm[Y + 1 + perm[Z]]].dot3(x - 1, y - 1, z);
-    var n111 = gradP[X + 1 + perm[Y + 1 + perm[Z + 1]]].dot3(
-      x - 1,
-      y - 1,
-      z - 1
-    );
-
-    // Compute the fade curve value for x, y, z
-    var u = fade(x);
-    var v = fade(y);
-    var w = fade(z);
-
-    // Interpolate
-    return lerp(
-      lerp(lerp(n000, n100, u), lerp(n001, n101, u), w),
-      lerp(lerp(n010, n110, u), lerp(n011, n111, u), w),
-      v
-    );
-  };
-
-  return module;
-}
diff --git a/public/examples/ts/heatmap-large-piecewise.ts b/public/examples/ts/heatmap-large-piecewise.ts
new file mode 100644
index 0000000..d793b53
--- /dev/null
+++ b/public/examples/ts/heatmap-large-piecewise.ts
@@ -0,0 +1,202 @@
+/*
+title: Heatmap - Discrete Mapping of Color
+category: heatmap
+titleCN: 热力图 - 颜色的离散映射
+difficulty: 2
+*/
+
+let noise = getNoiseHelper();
+let xData: number[] = [];
+let yData: number[] = [];
+noise.seed(Math.random());
+function generateData(theta: number, min: number, max: number) {
+  let data = [];
+  for (let i = 0; i <= 200; i++) {
+    for (let j = 0; j <= 100; j++) {
+      // let x = (max - min) * i / 200 + min;
+      // let y = (max - min) * j / 100 + min;
+      data.push([i, j, noise.perlin2(i / 40, j / 20) + 0.5]);
+      // data.push([i, j, normalDist(theta, x) * normalDist(theta, y)]);
+    }
+    xData.push(i);
+  }
+  for (let j = 0; j < 100; j++) {
+    yData.push(j);
+  }
+  return data;
+}
+let data = generateData(2, -5, 5);
+
+option = {
+  tooltip: {},
+  grid: {
+    right: 140,
+    left: 40
+  },
+  xAxis: {
+    type: 'category',
+    data: xData
+  },
+  yAxis: {
+    type: 'category',
+    data: yData
+  },
+  visualMap: {
+    type: 'piecewise',
+    min: 0,
+    max: 1,
+    left: 'right',
+    top: 'center',
+    calculable: true,
+    realtime: false,
+    splitNumber: 8,
+    inRange: {
+      color: [
+        '#313695',
+        '#4575b4',
+        '#74add1',
+        '#abd9e9',
+        '#e0f3f8',
+        '#ffffbf',
+        '#fee090',
+        '#fdae61',
+        '#f46d43',
+        '#d73027',
+        '#a50026'
+      ]
+    }
+  },
+  series: [
+    {
+      name: 'Gaussian',
+      type: 'heatmap',
+      data: data,
+      emphasis: {
+        itemStyle: {
+          borderColor: '#333',
+          borderWidth: 1
+        }
+      },
+      progressive: 1000,
+      animation: false
+    }
+  ]
+};
+
+///////////////////////////////////////////////////////////////////////////
+// perlin noise helper from https://github.com/josephg/noisejs
+///////////////////////////////////////////////////////////////////////////
+function getNoiseHelper() {
+  class Grad {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number) {
+      this.x = x;
+      this.y = y;
+      this.z = z;
+    }
+
+    dot2(x: number, y: number) {
+      return this.x * x + this.y * y;
+    }
+
+    dot3(x: number, y: number, z: number) {
+      return this.x * x + this.y * y + this.z * z;
+    }
+  }
+
+  const grad3 = [
+    new Grad(1, 1, 0),
+    new Grad(-1, 1, 0),
+    new Grad(1, -1, 0),
+    new Grad(-1, -1, 0),
+    new Grad(1, 0, 1),
+    new Grad(-1, 0, 1),
+    new Grad(1, 0, -1),
+    new Grad(-1, 0, -1),
+    new Grad(0, 1, 1),
+    new Grad(0, -1, 1),
+    new Grad(0, 1, -1),
+    new Grad(0, -1, -1)
+  ];
+  const p = [
+    151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140,
+    36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120,
+    234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
+    88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
+    134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133,
+    230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161,
+    1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130,
+    116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250,
+    124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227,
+    47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44,
+    154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98,
+    108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34,
+    242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14,
+    239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121,
+    50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243,
+    141, 128, 195, 78, 66, 215, 61, 156, 180
+  ];
+  // To remove the need for index wrapping, double the permutation table length
+  let perm = new Array(512);
+  let gradP = new Array(512);
+  // This isn't a very good seeding function, but it works ok. It supports 2^16
+  // different seed values. Write something better if you need more seeds.
+  function seed(seed: number) {
+    if (seed > 0 && seed < 1) {
+      // Scale the seed out
+      seed *= 65536;
+    }
+    seed = Math.floor(seed);
+    if (seed < 256) {
+      seed |= seed << 8;
+    }
+    for (let i = 0; i < 256; i++) {
+      let v;
+      if (i & 1) {
+        v = p[i] ^ (seed & 255);
+      } else {
+        v = p[i] ^ ((seed >> 8) & 255);
+      }
+      perm[i] = perm[i + 256] = v;
+      gradP[i] = gradP[i + 256] = grad3[v % 12];
+    }
+  }
+  seed(0);
+  // ##### Perlin noise stuff
+  function fade(t: number) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+  }
+  function lerp(a: number, b: number, t: number) {
+    return (1 - t) * a + t * b;
+  }
+  // 2D Perlin Noise
+  function perlin2(x: number, y: number) {
+    // Find unit grid cell containing point
+    let X = Math.floor(x),
+      Y = Math.floor(y);
+    // Get relative xy coordinates of point within that cell
+    x = x - X;
+    y = y - Y;
+    // Wrap the integer cells at 255 (smaller integer period can be introduced here)
+    X = X & 255;
+    Y = Y & 255;
+    // Calculate noise contributions from each of the four corners
+    let n00 = gradP[X + perm[Y]].dot2(x, y);
+    let n01 = gradP[X + perm[Y + 1]].dot2(x, y - 1);
+    let n10 = gradP[X + 1 + perm[Y]].dot2(x - 1, y);
+    let n11 = gradP[X + 1 + perm[Y + 1]].dot2(x - 1, y - 1);
+    // Compute the fade curve value for x
+    let u = fade(x);
+    // Interpolate the four results
+    return lerp(lerp(n00, n10, u), lerp(n01, n11, u), fade(y));
+  }
+
+  return {
+    seed,
+    perlin2
+  };
+}
+
+export {};
diff --git a/public/examples/ts/heatmap-large.js b/public/examples/ts/heatmap-large.js
deleted file mode 100644
index 0d4da71..0000000
--- a/public/examples/ts/heatmap-large.js
+++ /dev/null
@@ -1,441 +0,0 @@
-/*
-title: Heatmap - 20K data
-category: heatmap
-titleCN: 热力图 - 2w 数据
-difficulty: 2
-*/
-
-var noise = getNoiseHelper();
-var xData = [];
-var yData = [];
-noise.seed(Math.random());
-function generateData(theta, min, max) {
-  var data = [];
-  for (var i = 0; i <= 200; i++) {
-    for (var j = 0; j <= 100; j++) {
-      // var x = (max - min) * i / 200 + min;
-      // var y = (max - min) * j / 100 + min;
-      data.push([i, j, noise.perlin2(i / 40, j / 20) + 0.5]);
-      // data.push([i, j, normalDist(theta, x) * normalDist(theta, y)]);
-    }
-    xData.push(i);
-  }
-  for (var j = 0; j < 100; j++) {
-    yData.push(j);
-  }
-  return data;
-}
-var data = generateData(2, -5, 5);
-
-option = {
-  tooltip: {},
-  xAxis: {
-    type: 'category',
-    data: xData
-  },
-  yAxis: {
-    type: 'category',
-    data: yData
-  },
-  visualMap: {
-    min: 0,
-    max: 1,
-    calculable: true,
-    realtime: false,
-    inRange: {
-      color: [
-        '#313695',
-        '#4575b4',
-        '#74add1',
-        '#abd9e9',
-        '#e0f3f8',
-        '#ffffbf',
-        '#fee090',
-        '#fdae61',
-        '#f46d43',
-        '#d73027',
-        '#a50026'
-      ]
-    }
-  },
-  series: [
-    {
-      name: 'Gaussian',
-      type: 'heatmap',
-      data: data,
-      emphasis: {
-        itemStyle: {
-          borderColor: '#333',
-          borderWidth: 1
-        }
-      },
-      progressive: 1000,
-      animation: false
-    }
-  ]
-};
-
-///////////////////////////////////////////////////////////////////////////
-// Simplex and perlin noise helper from https://github.com/josephg/noisejs
-///////////////////////////////////////////////////////////////////////////
-function getNoiseHelper(global) {
-  var module = {};
-
-  function Grad(x, y, z) {
-    this.x = x;
-    this.y = y;
-    this.z = z;
-  }
-
-  Grad.prototype.dot2 = function (x, y) {
-    return this.x * x + this.y * y;
-  };
-
-  Grad.prototype.dot3 = function (x, y, z) {
-    return this.x * x + this.y * y + this.z * z;
-  };
-
-  var grad3 = [
-    new Grad(1, 1, 0),
-    new Grad(-1, 1, 0),
-    new Grad(1, -1, 0),
-    new Grad(-1, -1, 0),
-    new Grad(1, 0, 1),
-    new Grad(-1, 0, 1),
-    new Grad(1, 0, -1),
-    new Grad(-1, 0, -1),
-    new Grad(0, 1, 1),
-    new Grad(0, -1, 1),
-    new Grad(0, 1, -1),
-    new Grad(0, -1, -1)
-  ];
-
-  var p = [
-    151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140,
-    36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120,
-    234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
-    88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
-    134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133,
-    230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161,
-    1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130,
-    116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250,
-    124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227,
-    47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44,
-    154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98,
-    108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34,
-    242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14,
-    239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121,
-    50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243,
-    141, 128, 195, 78, 66, 215, 61, 156, 180
-  ];
-  // To remove the need for index wrapping, double the permutation table length
-  var perm = new Array(512);
-  var gradP = new Array(512);
-
-  // This isn't a very good seeding function, but it works ok. It supports 2^16
-  // different seed values. Write something better if you need more seeds.
-  module.seed = function (seed) {
-    if (seed > 0 && seed < 1) {
-      // Scale the seed out
-      seed *= 65536;
-    }
-
-    seed = Math.floor(seed);
-    if (seed < 256) {
-      seed |= seed << 8;
-    }
-
-    for (var i = 0; i < 256; i++) {
-      var v;
-      if (i & 1) {
-        v = p[i] ^ (seed & 255);
-      } else {
-        v = p[i] ^ ((seed >> 8) & 255);
-      }
-
-      perm[i] = perm[i + 256] = v;
-      gradP[i] = gradP[i + 256] = grad3[v % 12];
-    }
-  };
-
-  module.seed(0);
-
-  /*
-  for(var i=0; i<256; i++) {
-    perm[i] = perm[i + 256] = p[i];
-    gradP[i] = gradP[i + 256] = grad3[perm[i] % 12];
-  }*/
-
-  // Skewing and unskewing factors for 2, 3, and 4 dimensions
-  var F2 = 0.5 * (Math.sqrt(3) - 1);
-  var G2 = (3 - Math.sqrt(3)) / 6;
-
-  var F3 = 1 / 3;
-  var G3 = 1 / 6;
-
-  // 2D simplex noise
-  module.simplex2 = function (xin, yin) {
-    var n0, n1, n2; // Noise contributions from the three corners
-    // Skew the input space to determine which simplex cell we're in
-    var s = (xin + yin) * F2; // Hairy factor for 2D
-    var i = Math.floor(xin + s);
-    var j = Math.floor(yin + s);
-    var t = (i + j) * G2;
-    var x0 = xin - i + t; // The x,y distances from the cell origin, unskewed.
-    var y0 = yin - j + t;
-    // For the 2D case, the simplex shape is an equilateral triangle.
-    // Determine which simplex we are in.
-    var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
-    if (x0 > y0) {
-      // lower triangle, XY order: (0,0)->(1,0)->(1,1)
-      i1 = 1;
-      j1 = 0;
-    } else {
-      // upper triangle, YX order: (0,0)->(0,1)->(1,1)
-      i1 = 0;
-      j1 = 1;
-    }
-    // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
-    // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
-    // c = (3-sqrt(3))/6
-    var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
-    var y1 = y0 - j1 + G2;
-    var x2 = x0 - 1 + 2 * G2; // Offsets for last corner in (x,y) unskewed coords
-    var y2 = y0 - 1 + 2 * G2;
-    // Work out the hashed gradient indices of the three simplex corners
-    i &= 255;
-    j &= 255;
-    var gi0 = gradP[i + perm[j]];
-    var gi1 = gradP[i + i1 + perm[j + j1]];
-    var gi2 = gradP[i + 1 + perm[j + 1]];
-    // Calculate the contribution from the three corners
-    var t0 = 0.5 - x0 * x0 - y0 * y0;
-    if (t0 < 0) {
-      n0 = 0;
-    } else {
-      t0 *= t0;
-      n0 = t0 * t0 * gi0.dot2(x0, y0); // (x,y) of grad3 used for 2D gradient
-    }
-    var t1 = 0.5 - x1 * x1 - y1 * y1;
-    if (t1 < 0) {
-      n1 = 0;
-    } else {
-      t1 *= t1;
-      n1 = t1 * t1 * gi1.dot2(x1, y1);
-    }
-    var t2 = 0.5 - x2 * x2 - y2 * y2;
-    if (t2 < 0) {
-      n2 = 0;
-    } else {
-      t2 *= t2;
-      n2 = t2 * t2 * gi2.dot2(x2, y2);
-    }
-    // Add contributions from each corner to get the final noise value.
-    // The result is scaled to return values in the interval [-1,1].
-    return 70 * (n0 + n1 + n2);
-  };
-
-  // 3D simplex noise
-  module.simplex3 = function (xin, yin, zin) {
-    var n0, n1, n2, n3; // Noise contributions from the four corners
-
-    // Skew the input space to determine which simplex cell we're in
-    var s = (xin + yin + zin) * F3; // Hairy factor for 2D
-    var i = Math.floor(xin + s);
-    var j = Math.floor(yin + s);
-    var k = Math.floor(zin + s);
-
-    var t = (i + j + k) * G3;
-    var x0 = xin - i + t; // The x,y distances from the cell origin, unskewed.
-    var y0 = yin - j + t;
-    var z0 = zin - k + t;
-
-    // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
-    // Determine which simplex we are in.
-    var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
-    var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
-    if (x0 >= y0) {
-      if (y0 >= z0) {
-        i1 = 1;
-        j1 = 0;
-        k1 = 0;
-        i2 = 1;
-        j2 = 1;
-        k2 = 0;
-      } else if (x0 >= z0) {
-        i1 = 1;
-        j1 = 0;
-        k1 = 0;
-        i2 = 1;
-        j2 = 0;
-        k2 = 1;
-      } else {
-        i1 = 0;
-        j1 = 0;
-        k1 = 1;
-        i2 = 1;
-        j2 = 0;
-        k2 = 1;
-      }
-    } else {
-      if (y0 < z0) {
-        i1 = 0;
-        j1 = 0;
-        k1 = 1;
-        i2 = 0;
-        j2 = 1;
-        k2 = 1;
-      } else if (x0 < z0) {
-        i1 = 0;
-        j1 = 1;
-        k1 = 0;
-        i2 = 0;
-        j2 = 1;
-        k2 = 1;
-      } else {
-        i1 = 0;
-        j1 = 1;
-        k1 = 0;
-        i2 = 1;
-        j2 = 1;
-        k2 = 0;
-      }
-    }
-    // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
-    // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
-    // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
-    // c = 1/6.
-    var x1 = x0 - i1 + G3; // Offsets for second corner
-    var y1 = y0 - j1 + G3;
-    var z1 = z0 - k1 + G3;
-
-    var x2 = x0 - i2 + 2 * G3; // Offsets for third corner
-    var y2 = y0 - j2 + 2 * G3;
-    var z2 = z0 - k2 + 2 * G3;
-
-    var x3 = x0 - 1 + 3 * G3; // Offsets for fourth corner
-    var y3 = y0 - 1 + 3 * G3;
-    var z3 = z0 - 1 + 3 * G3;
-
-    // Work out the hashed gradient indices of the four simplex corners
-    i &= 255;
-    j &= 255;
-    k &= 255;
-    var gi0 = gradP[i + perm[j + perm[k]]];
-    var gi1 = gradP[i + i1 + perm[j + j1 + perm[k + k1]]];
-    var gi2 = gradP[i + i2 + perm[j + j2 + perm[k + k2]]];
-    var gi3 = gradP[i + 1 + perm[j + 1 + perm[k + 1]]];
-
-    // Calculate the contribution from the four corners
-    var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
-    if (t0 < 0) {
-      n0 = 0;
-    } else {
-      t0 *= t0;
-      n0 = t0 * t0 * gi0.dot3(x0, y0, z0); // (x,y) of grad3 used for 2D gradient
-    }
-    var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
-    if (t1 < 0) {
-      n1 = 0;
-    } else {
-      t1 *= t1;
-      n1 = t1 * t1 * gi1.dot3(x1, y1, z1);
-    }
-    var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
-    if (t2 < 0) {
-      n2 = 0;
-    } else {
-      t2 *= t2;
-      n2 = t2 * t2 * gi2.dot3(x2, y2, z2);
-    }
-    var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
-    if (t3 < 0) {
-      n3 = 0;
-    } else {
-      t3 *= t3;
-      n3 = t3 * t3 * gi3.dot3(x3, y3, z3);
-    }
-    // Add contributions from each corner to get the final noise value.
-    // The result is scaled to return values in the interval [-1,1].
-    return 32 * (n0 + n1 + n2 + n3);
-  };
-
-  // ##### Perlin noise stuff
-
-  function fade(t) {
-    return t * t * t * (t * (t * 6 - 15) + 10);
-  }
-
-  function lerp(a, b, t) {
-    return (1 - t) * a + t * b;
-  }
-
-  // 2D Perlin Noise
-  module.perlin2 = function (x, y) {
-    // Find unit grid cell containing point
-    var X = Math.floor(x),
-      Y = Math.floor(y);
-    // Get relative xy coordinates of point within that cell
-    x = x - X;
-    y = y - Y;
-    // Wrap the integer cells at 255 (smaller integer period can be introduced here)
-    X = X & 255;
-    Y = Y & 255;
-
-    // Calculate noise contributions from each of the four corners
-    var n00 = gradP[X + perm[Y]].dot2(x, y);
-    var n01 = gradP[X + perm[Y + 1]].dot2(x, y - 1);
-    var n10 = gradP[X + 1 + perm[Y]].dot2(x - 1, y);
-    var n11 = gradP[X + 1 + perm[Y + 1]].dot2(x - 1, y - 1);
-
-    // Compute the fade curve value for x
-    var u = fade(x);
-
-    // Interpolate the four results
-    return lerp(lerp(n00, n10, u), lerp(n01, n11, u), fade(y));
-  };
-
-  // 3D Perlin Noise
-  module.perlin3 = function (x, y, z) {
-    // Find unit grid cell containing point
-    var X = Math.floor(x),
-      Y = Math.floor(y),
-      Z = Math.floor(z);
-    // Get relative xyz coordinates of point within that cell
-    x = x - X;
-    y = y - Y;
-    z = z - Z;
-    // Wrap the integer cells at 255 (smaller integer period can be introduced here)
-    X = X & 255;
-    Y = Y & 255;
-    Z = Z & 255;
-
-    // Calculate noise contributions from each of the eight corners
-    var n000 = gradP[X + perm[Y + perm[Z]]].dot3(x, y, z);
-    var n001 = gradP[X + perm[Y + perm[Z + 1]]].dot3(x, y, z - 1);
-    var n010 = gradP[X + perm[Y + 1 + perm[Z]]].dot3(x, y - 1, z);
-    var n011 = gradP[X + perm[Y + 1 + perm[Z + 1]]].dot3(x, y - 1, z - 1);
-    var n100 = gradP[X + 1 + perm[Y + perm[Z]]].dot3(x - 1, y, z);
-    var n101 = gradP[X + 1 + perm[Y + perm[Z + 1]]].dot3(x - 1, y, z - 1);
-    var n110 = gradP[X + 1 + perm[Y + 1 + perm[Z]]].dot3(x - 1, y - 1, z);
-    var n111 = gradP[X + 1 + perm[Y + 1 + perm[Z + 1]]].dot3(
-      x - 1,
-      y - 1,
-      z - 1
-    );
-
-    // Compute the fade curve value for x, y, z
-    var u = fade(x);
-    var v = fade(y);
-    var w = fade(z);
-
-    // Interpolate
-    return lerp(
-      lerp(lerp(n000, n100, u), lerp(n001, n101, u), w),
-      lerp(lerp(n010, n110, u), lerp(n011, n111, u), w),
-      v
-    );
-  };
-
-  return module;
-}
diff --git a/public/examples/ts/heatmap-large.ts b/public/examples/ts/heatmap-large.ts
new file mode 100644
index 0000000..f4c055d
--- /dev/null
+++ b/public/examples/ts/heatmap-large.ts
@@ -0,0 +1,192 @@
+/*
+title: Heatmap - 20K data
+category: heatmap
+titleCN: 热力图 - 2w 数据
+difficulty: 2
+*/
+let noise = getNoiseHelper();
+let xData: number[] = [];
+let yData: number[] = [];
+noise.seed(Math.random());
+function generateData(theta: number, min: number, max: number) {
+  let data: number[][] = [];
+  for (let i = 0; i <= 200; i++) {
+    for (let j = 0; j <= 100; j++) {
+      // let x = (max - min) * i / 200 + min;
+      // let y = (max - min) * j / 100 + min;
+      data.push([i, j, noise.perlin2(i / 40, j / 20) + 0.5]);
+      // data.push([i, j, normalDist(theta, x) * normalDist(theta, y)]);
+    }
+    xData.push(i);
+  }
+  for (let j = 0; j < 100; j++) {
+    yData.push(j);
+  }
+  return data;
+}
+let data = generateData(2, -5, 5);
+
+option = {
+  tooltip: {},
+  xAxis: {
+    type: 'category',
+    data: xData
+  },
+  yAxis: {
+    type: 'category',
+    data: yData
+  },
+  visualMap: {
+    min: 0,
+    max: 1,
+    calculable: true,
+    realtime: false,
+    inRange: {
+      color: [
+        '#313695',
+        '#4575b4',
+        '#74add1',
+        '#abd9e9',
+        '#e0f3f8',
+        '#ffffbf',
+        '#fee090',
+        '#fdae61',
+        '#f46d43',
+        '#d73027',
+        '#a50026'
+      ]
+    }
+  },
+  series: [
+    {
+      name: 'Gaussian',
+      type: 'heatmap',
+      data: data,
+      emphasis: {
+        itemStyle: {
+          borderColor: '#333',
+          borderWidth: 1
+        }
+      },
+      progressive: 1000,
+      animation: false
+    }
+  ]
+};
+///////////////////////////////////////////////////////////////////////////
+// perlin noise helper from https://github.com/josephg/noisejs
+///////////////////////////////////////////////////////////////////////////
+function getNoiseHelper() {
+  class Grad {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number) {
+      this.x = x;
+      this.y = y;
+      this.z = z;
+    }
+
+    dot2(x: number, y: number) {
+      return this.x * x + this.y * y;
+    }
+
+    dot3(x: number, y: number, z: number) {
+      return this.x * x + this.y * y + this.z * z;
+    }
+  }
+
+  const grad3 = [
+    new Grad(1, 1, 0),
+    new Grad(-1, 1, 0),
+    new Grad(1, -1, 0),
+    new Grad(-1, -1, 0),
+    new Grad(1, 0, 1),
+    new Grad(-1, 0, 1),
+    new Grad(1, 0, -1),
+    new Grad(-1, 0, -1),
+    new Grad(0, 1, 1),
+    new Grad(0, -1, 1),
+    new Grad(0, 1, -1),
+    new Grad(0, -1, -1)
+  ];
+  const p = [
+    151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140,
+    36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120,
+    234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
+    88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
+    134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133,
+    230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161,
+    1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130,
+    116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250,
+    124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227,
+    47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44,
+    154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98,
+    108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34,
+    242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14,
+    239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121,
+    50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243,
+    141, 128, 195, 78, 66, 215, 61, 156, 180
+  ];
+  // To remove the need for index wrapping, double the permutation table length
+  let perm = new Array(512);
+  let gradP = new Array(512);
+  // This isn't a very good seeding function, but it works ok. It supports 2^16
+  // different seed values. Write something better if you need more seeds.
+  function seed(seed: number) {
+    if (seed > 0 && seed < 1) {
+      // Scale the seed out
+      seed *= 65536;
+    }
+    seed = Math.floor(seed);
+    if (seed < 256) {
+      seed |= seed << 8;
+    }
+    for (let i = 0; i < 256; i++) {
+      let v;
+      if (i & 1) {
+        v = p[i] ^ (seed & 255);
+      } else {
+        v = p[i] ^ ((seed >> 8) & 255);
+      }
+      perm[i] = perm[i + 256] = v;
+      gradP[i] = gradP[i + 256] = grad3[v % 12];
+    }
+  }
+  seed(0);
+  // ##### Perlin noise stuff
+  function fade(t: number) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+  }
+  function lerp(a: number, b: number, t: number) {
+    return (1 - t) * a + t * b;
+  }
+  // 2D Perlin Noise
+  function perlin2(x: number, y: number) {
+    // Find unit grid cell containing point
+    let X = Math.floor(x),
+      Y = Math.floor(y);
+    // Get relative xy coordinates of point within that cell
+    x = x - X;
+    y = y - Y;
+    // Wrap the integer cells at 255 (smaller integer period can be introduced here)
+    X = X & 255;
+    Y = Y & 255;
+    // Calculate noise contributions from each of the four corners
+    let n00 = gradP[X + perm[Y]].dot2(x, y);
+    let n01 = gradP[X + perm[Y + 1]].dot2(x, y - 1);
+    let n10 = gradP[X + 1 + perm[Y]].dot2(x - 1, y);
+    let n11 = gradP[X + 1 + perm[Y + 1]].dot2(x - 1, y - 1);
+    // Compute the fade curve value for x
+    let u = fade(x);
+    // Interpolate the four results
+    return lerp(lerp(n00, n10, u), lerp(n01, n11, u), fade(y));
+  }
+
+  return {
+    seed,
+    perlin2
+  };
+}
+
+export {};
diff --git a/public/examples/ts/line-draggable.ts b/public/examples/ts/line-draggable.ts
index 3c81fc9..638a8a2 100644
--- a/public/examples/ts/line-draggable.ts
+++ b/public/examples/ts/line-draggable.ts
@@ -2,7 +2,7 @@
 title: Draggable Points
 category: 'line, graphic'
 titleCN: 可拖拽点
-difficulty: 10
+difficulty: 12
 */
 
 const symbolSize = 20;
diff --git a/public/examples/ts/line-graphic.ts b/public/examples/ts/line-graphic.ts
index e8b6763..3989ac2 100644
--- a/public/examples/ts/line-graphic.ts
+++ b/public/examples/ts/line-graphic.ts
@@ -1,7 +1,7 @@
 /*
 title: Custom Graphic Component
 titleCN: 自定义图形组件
-category: line
+category: line, graphic
 difficulty: 9
 */
 

---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@echarts.apache.org
For additional commands, e-mail: commits-help@echarts.apache.org