First commit.

Signed-off-by: Chen Xiao <abigwc@gmail.com>

client/node_modules/points-on-curve/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Preet Shihn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

client/node_modules/points-on-curve/README.md

@@ -0,0 +1,90 @@
+# points-on-curve
+
+This package calculate the points on a curve with a certain tolerance. It can also simplify the shape to use fewer points. 
+This can really be useful when estimating lines/polygons for curves in WebGL or for Hit/Collision detections. 
+
+## Install
+
+From npm
+
+```
+npm install --save points-on-curve
+```
+
+The package is distributed as an ES6 module. 
+
+## API
+
+### pointsOnBezierCurves(points: Point[], tolerance?: number, distance?: number): Point[]
+
+You pass in the points representing a bezier curve. Each point is an array of two numbers e.g. `[100, 123]`.
+
+The points can also be a set of continuous curves where the last poing on the `Nth` curve acts as the first point of the next. 
+
+```javascript
+import { pointsOnBezierCurves } from 'points-on-curve';
+
+const curve = [[70,240],[145,60],[275,90],[300,230]];
+const points = pointsOnBezierCurves(curve);
+// plotPoints(points);
+```
+
+![points on bezier](https://user-images.githubusercontent.com/833927/79051836-45630300-7be7-11ea-8cb6-cba2695a4807.png)
+
+Same can be rendered with more **tolerance** (default value is 0.15):
+
+```javascript
+const points = pointsOnBezierCurves(curve, 0.7);
+```
+![points on bezier with 0.7 tolerance](https://user-images.githubusercontent.com/833927/79051837-45fb9980-7be7-11ea-9583-52cf882e770e.png)
+
+Note that this method does not accept the number of points to render, but takes in a tolerance level which allows for better distribution of points. 
+
+The value of **tolerance** can be between 0 and 1. It is used to decide how many points are needed in a section of the curve. The algorithm determined the *flatness* of a section of the curve and compares it to the *tolerance* level, if less flat, the segment gets further divided into 2 segments. 
+
+
+#### Simplifying path
+
+Based on the tolerance alone, this algorithm nicely provides enough points to represent a curve. It does not, however, efficiently get rid of unneeded points. The second *optional* argument in function, **distance** helps with that. If a `distance` value is provided, the method uses the [Ramer–Douglas–Peucker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm) to reduce the points. 
+
+```javascript
+const points = pointsOnBezierCurves(curve, 0.2, 0.15);
+```
+
+Following are the points generated with distance values of `0.15`, `0.75`, `1.5`, and `3.0`
+
+![points with 0.15d](https://user-images.githubusercontent.com/833927/79051853-53b11f00-7be7-11ea-8970-7cc3f7621142.png)
+![points with 0.75d](https://user-images.githubusercontent.com/833927/79051854-5449b580-7be7-11ea-9601-a1dd418b10d8.png)
+![points with 1.5d](https://user-images.githubusercontent.com/833927/79051855-5449b580-7be7-11ea-9ab4-139beb0faf11.png)
+![points with 3.0d](https://user-images.githubusercontent.com/833927/79051856-54e24c00-7be7-11ea-9f52-34e3ad9c81bd.png)
+
+### curveToBezier(pointsIn: Point[]): Point[]
+
+Sometimes it's hard to think of shape as a set of cubic bezier curves, each curve with 2 controls points. It is simple to just think of them as a curve passing through a set of points. 
+
+This method turns those set of points to a set of points representing bezier curves.
+
+```javascript
+import { curveToBezier } from 'points-on-curve/lib/curve-to-bezier.js';
+
+const curvePoints = [
+  [20, 240],
+  [95, 69],
+  [225, 90],
+  [250, 180],
+  [290, 220],
+  [380, 80],
+];
+const bcurve = curveToBezier(curvePoints);
+// .. Plot bcurve
+```
+![Curve through points](https://user-images.githubusercontent.com/833927/79051797-12b90a80-7be7-11ea-92d2-5cb79adcbe30.png)
+
+Now that we have bezier points, these could be passed to `pointsOnBezierCurves` function to get the points on the curve
+
+![Curve through points](https://user-images.githubusercontent.com/833927/79051798-1351a100-7be7-11ea-8465-959a22b72371.png)
+
+
+## License
+[MIT License](https://github.com/pshihn/bezier-points/blob/master/LICENSE)
+

client/node_modules/points-on-curve/lib/curve-to-bezier.d.ts

@@ -0,0 +1,2 @@
+import { Point } from './index.js';
+export declare function curveToBezier(pointsIn: Point[], curveTightness?: number): Point[];

client/node_modules/points-on-curve/lib/curve-to-bezier.js

@@ -0,0 +1,35 @@
+function clone(p) {
+    return [...p];
+}
+export function curveToBezier(pointsIn, curveTightness = 0) {
+    const len = pointsIn.length;
+    if (len < 3) {
+        throw new Error('A curve must have at least three points.');
+    }
+    const out = [];
+    if (len === 3) {
+        out.push(clone(pointsIn[0]), clone(pointsIn[1]), clone(pointsIn[2]), clone(pointsIn[2]));
+    }
+    else {
+        const points = [];
+        points.push(pointsIn[0], pointsIn[0]);
+        for (let i = 1; i < pointsIn.length; i++) {
+            points.push(pointsIn[i]);
+            if (i === (pointsIn.length - 1)) {
+                points.push(pointsIn[i]);
+            }
+        }
+        const b = [];
+        const s = 1 - curveTightness;
+        out.push(clone(points[0]));
+        for (let i = 1; (i + 2) < points.length; i++) {
+            const cachedVertArray = points[i];
+            b[0] = [cachedVertArray[0], cachedVertArray[1]];
+            b[1] = [cachedVertArray[0] + (s * points[i + 1][0] - s * points[i - 1][0]) / 6, cachedVertArray[1] + (s * points[i + 1][1] - s * points[i - 1][1]) / 6];
+            b[2] = [points[i + 1][0] + (s * points[i][0] - s * points[i + 2][0]) / 6, points[i + 1][1] + (s * points[i][1] - s * points[i + 2][1]) / 6];
+            b[3] = [points[i + 1][0], points[i + 1][1]];
+            out.push(b[1], b[2], b[3]);
+        }
+    }
+    return out;
+}

client/node_modules/points-on-curve/lib/index.d.ts

@@ -0,0 +1,3 @@
+export declare type Point = [number, number];
+export declare function simplify(points: Point[], distance: number): Point[];
+export declare function pointsOnBezierCurves(points: Point[], tolerance?: number, distance?: number): Point[];

client/node_modules/points-on-curve/lib/index.js

@@ -0,0 +1,123 @@
+// distance between 2 points
+function distance(p1, p2) {
+    return Math.sqrt(distanceSq(p1, p2));
+}
+// distance between 2 points squared
+function distanceSq(p1, p2) {
+    return Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2);
+}
+// Sistance squared from a point p to the line segment vw
+function distanceToSegmentSq(p, v, w) {
+    const l2 = distanceSq(v, w);
+    if (l2 === 0) {
+        return distanceSq(p, v);
+    }
+    let t = ((p[0] - v[0]) * (w[0] - v[0]) + (p[1] - v[1]) * (w[1] - v[1])) / l2;
+    t = Math.max(0, Math.min(1, t));
+    return distanceSq(p, lerp(v, w, t));
+}
+function lerp(a, b, t) {
+    return [
+        a[0] + (b[0] - a[0]) * t,
+        a[1] + (b[1] - a[1]) * t,
+    ];
+}
+// Adapted from https://seant23.wordpress.com/2010/11/12/offset-bezier-curves/
+function flatness(points, offset) {
+    const p1 = points[offset + 0];
+    const p2 = points[offset + 1];
+    const p3 = points[offset + 2];
+    const p4 = points[offset + 3];
+    let ux = 3 * p2[0] - 2 * p1[0] - p4[0];
+    ux *= ux;
+    let uy = 3 * p2[1] - 2 * p1[1] - p4[1];
+    uy *= uy;
+    let vx = 3 * p3[0] - 2 * p4[0] - p1[0];
+    vx *= vx;
+    let vy = 3 * p3[1] - 2 * p4[1] - p1[1];
+    vy *= vy;
+    if (ux < vx) {
+        ux = vx;
+    }
+    if (uy < vy) {
+        uy = vy;
+    }
+    return ux + uy;
+}
+function getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints) {
+    const outPoints = newPoints || [];
+    if (flatness(points, offset) < tolerance) {
+        const p0 = points[offset + 0];
+        if (outPoints.length) {
+            const d = distance(outPoints[outPoints.length - 1], p0);
+            if (d > 1) {
+                outPoints.push(p0);
+            }
+        }
+        else {
+            outPoints.push(p0);
+        }
+        outPoints.push(points[offset + 3]);
+    }
+    else {
+        // subdivide
+        const t = .5;
+        const p1 = points[offset + 0];
+        const p2 = points[offset + 1];
+        const p3 = points[offset + 2];
+        const p4 = points[offset + 3];
+        const q1 = lerp(p1, p2, t);
+        const q2 = lerp(p2, p3, t);
+        const q3 = lerp(p3, p4, t);
+        const r1 = lerp(q1, q2, t);
+        const r2 = lerp(q2, q3, t);
+        const red = lerp(r1, r2, t);
+        getPointsOnBezierCurveWithSplitting([p1, q1, r1, red], 0, tolerance, outPoints);
+        getPointsOnBezierCurveWithSplitting([red, r2, q3, p4], 0, tolerance, outPoints);
+    }
+    return outPoints;
+}
+export function simplify(points, distance) {
+    return simplifyPoints(points, 0, points.length, distance);
+}
+// Ramer–Douglas–Peucker algorithm
+// https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm
+function simplifyPoints(points, start, end, epsilon, newPoints) {
+    const outPoints = newPoints || [];
+    // find the most distance point from the endpoints
+    const s = points[start];
+    const e = points[end - 1];
+    let maxDistSq = 0;
+    let maxNdx = 1;
+    for (let i = start + 1; i < end - 1; ++i) {
+        const distSq = distanceToSegmentSq(points[i], s, e);
+        if (distSq > maxDistSq) {
+            maxDistSq = distSq;
+            maxNdx = i;
+        }
+    }
+    // if that point is too far, split
+    if (Math.sqrt(maxDistSq) > epsilon) {
+        simplifyPoints(points, start, maxNdx + 1, epsilon, outPoints);
+        simplifyPoints(points, maxNdx, end, epsilon, outPoints);
+    }
+    else {
+        if (!outPoints.length) {
+            outPoints.push(s);
+        }
+        outPoints.push(e);
+    }
+    return outPoints;
+}
+export function pointsOnBezierCurves(points, tolerance = 0.15, distance) {
+    const newPoints = [];
+    const numSegments = (points.length - 1) / 3;
+    for (let i = 0; i < numSegments; i++) {
+        const offset = i * 3;
+        getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints);
+    }
+    if (distance && distance > 0) {
+        return simplifyPoints(newPoints, 0, newPoints.length, distance);
+    }
+    return newPoints;
+}

client/node_modules/points-on-curve/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "points-on-curve",
+  "version": "0.2.0",
+  "description": "Estimate points on a bezier curve or a set of connexted bezier curves",
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "rm -rf lib && tsc",
+    "lint": "tslint -p tsconfig.json",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pshihn/bezier-points.git"
+  },
+  "keywords": [
+    "Bezier",
+    "graphics"
+  ],
+  "author": "Preet Shihn",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pshihn/bezier-points/issues"
+  },
+  "homepage": "https://github.com/pshihn/bezier-points#readme",
+  "devDependencies": {
+    "tslint": "^6.1.1",
+    "typescript": "^3.8.3"
+  }
+}

client/node_modules/points-on-curve/src/curve-to-bezier.ts

@@ -0,0 +1,42 @@
+import { Point } from './index.js';
+
+function clone(p: Point): Point {
+  return [...p] as Point;
+}
+
+export function curveToBezier(pointsIn: Point[], curveTightness = 0): Point[] {
+  const len = pointsIn.length;
+  if (len < 3) {
+    throw new Error('A curve must have at least three points.');
+  }
+  const out: Point[] = [];
+  if (len === 3) {
+    out.push(
+      clone(pointsIn[0]),
+      clone(pointsIn[1]),
+      clone(pointsIn[2]),
+      clone(pointsIn[2])
+    );
+  } else {
+    const points: Point[] = [];
+    points.push(pointsIn[0], pointsIn[0]);
+    for (let i = 1; i < pointsIn.length; i++) {
+      points.push(pointsIn[i]);
+      if (i === (pointsIn.length - 1)) {
+        points.push(pointsIn[i]);
+      }
+    }
+    const b: Point[] = [];
+    const s = 1 - curveTightness;
+    out.push(clone(points[0]));
+    for (let i = 1; (i + 2) < points.length; i++) {
+      const cachedVertArray = points[i];
+      b[0] = [cachedVertArray[0], cachedVertArray[1]];
+      b[1] = [cachedVertArray[0] + (s * points[i + 1][0] - s * points[i - 1][0]) / 6, cachedVertArray[1] + (s * points[i + 1][1] - s * points[i - 1][1]) / 6];
+      b[2] = [points[i + 1][0] + (s * points[i][0] - s * points[i + 2][0]) / 6, points[i + 1][1] + (s * points[i][1] - s * points[i + 2][1]) / 6];
+      b[3] = [points[i + 1][0], points[i + 1][1]];
+      out.push(b[1], b[2], b[3]);
+    }
+  }
+  return out;
+}

client/node_modules/points-on-curve/src/index.ts

@@ -0,0 +1,137 @@
+export type Point = [number, number];
+
+// distance between 2 points
+function distance(p1: Point, p2: Point): number {
+  return Math.sqrt(distanceSq(p1, p2));
+}
+
+// distance between 2 points squared
+function distanceSq(p1: Point, p2: Point): number {
+  return Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2);
+}
+
+// Sistance squared from a point p to the line segment vw
+function distanceToSegmentSq(p: Point, v: Point, w: Point): number {
+  const l2 = distanceSq(v, w);
+  if (l2 === 0) {
+    return distanceSq(p, v);
+  }
+  let t = ((p[0] - v[0]) * (w[0] - v[0]) + (p[1] - v[1]) * (w[1] - v[1])) / l2;
+  t = Math.max(0, Math.min(1, t));
+  return distanceSq(p, lerp(v, w, t));
+}
+
+function lerp(a: Point, b: Point, t: number): Point {
+  return [
+    a[0] + (b[0] - a[0]) * t,
+    a[1] + (b[1] - a[1]) * t,
+  ];
+}
+
+// Adapted from https://seant23.wordpress.com/2010/11/12/offset-bezier-curves/
+function flatness(points: Point[], offset: number): number {
+  const p1 = points[offset + 0];
+  const p2 = points[offset + 1];
+  const p3 = points[offset + 2];
+  const p4 = points[offset + 3];
+
+  let ux = 3 * p2[0] - 2 * p1[0] - p4[0]; ux *= ux;
+  let uy = 3 * p2[1] - 2 * p1[1] - p4[1]; uy *= uy;
+  let vx = 3 * p3[0] - 2 * p4[0] - p1[0]; vx *= vx;
+  let vy = 3 * p3[1] - 2 * p4[1] - p1[1]; vy *= vy;
+
+  if (ux < vx) {
+    ux = vx;
+  }
+
+  if (uy < vy) {
+    uy = vy;
+  }
+
+  return ux + uy;
+}
+
+function getPointsOnBezierCurveWithSplitting(points: Point[], offset: number, tolerance: number, newPoints?: Point[]): Point[] {
+  const outPoints = newPoints || [];
+  if (flatness(points, offset) < tolerance) {
+    const p0 = points[offset + 0];
+    if (outPoints.length) {
+      const d = distance(outPoints[outPoints.length - 1], p0);
+      if (d > 1) {
+        outPoints.push(p0);
+      }
+    } else {
+      outPoints.push(p0);
+    }
+    outPoints.push(points[offset + 3]);
+  } else {
+    // subdivide
+    const t = .5;
+    const p1 = points[offset + 0];
+    const p2 = points[offset + 1];
+    const p3 = points[offset + 2];
+    const p4 = points[offset + 3];
+
+    const q1 = lerp(p1, p2, t);
+    const q2 = lerp(p2, p3, t);
+    const q3 = lerp(p3, p4, t);
+
+    const r1 = lerp(q1, q2, t);
+    const r2 = lerp(q2, q3, t);
+
+    const red = lerp(r1, r2, t);
+
+    getPointsOnBezierCurveWithSplitting([p1, q1, r1, red], 0, tolerance, outPoints);
+    getPointsOnBezierCurveWithSplitting([red, r2, q3, p4], 0, tolerance, outPoints);
+  }
+  return outPoints;
+}
+
+export function simplify(points: Point[], distance: number): Point[] {
+  return simplifyPoints(points, 0, points.length, distance);
+}
+
+// Ramer–Douglas–Peucker algorithm
+// https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm
+function simplifyPoints(points: Point[], start: number, end: number, epsilon: number, newPoints?: Point[]): Point[] {
+  const outPoints = newPoints || [];
+
+  // find the most distance point from the endpoints
+  const s = points[start];
+  const e = points[end - 1];
+  let maxDistSq = 0;
+  let maxNdx = 1;
+  for (let i = start + 1; i < end - 1; ++i) {
+    const distSq = distanceToSegmentSq(points[i], s, e);
+    if (distSq > maxDistSq) {
+      maxDistSq = distSq;
+      maxNdx = i;
+    }
+  }
+
+  // if that point is too far, split
+  if (Math.sqrt(maxDistSq) > epsilon) {
+    simplifyPoints(points, start, maxNdx + 1, epsilon, outPoints);
+    simplifyPoints(points, maxNdx, end, epsilon, outPoints);
+  } else {
+    if (!outPoints.length) {
+      outPoints.push(s);
+    }
+    outPoints.push(e);
+  }
+
+  return outPoints;
+}
+
+export function pointsOnBezierCurves(points: Point[], tolerance: number = 0.15, distance?: number): Point[] {
+  const newPoints: Point[] = [];
+  const numSegments = (points.length - 1) / 3;
+  for (let i = 0; i < numSegments; i++) {
+    const offset = i * 3;
+    getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints);
+  }
+  if (distance && distance > 0) {
+    return simplifyPoints(newPoints, 0, newPoints.length, distance);
+  }
+  return newPoints;
+}

client/node_modules/points-on-curve/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "es2015",
+    "moduleResolution": "node",
+    "lib": [
+      "es2017"
+    ],
+    "declaration": true,
+    "outDir": "./lib",
+    "baseUrl": ".",
+    "strict": true,
+    "strictNullChecks": true,
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

client/node_modules/points-on-curve/tslint.json

@@ -0,0 +1,61 @@
+{
+  "rules": {
+    "arrow-parens": true,
+    "class-name": true,
+    "indent": [
+      true,
+      "spaces",
+      2
+    ],
+    "prefer-const": true,
+    "no-duplicate-variable": true,
+    "no-eval": true,
+    "no-internal-module": true,
+    "no-trailing-whitespace": false,
+    "no-var-keyword": true,
+    "one-line": [
+      true,
+      "check-open-brace",
+      "check-whitespace"
+    ],
+    "quotemark": [
+      true,
+      "single",
+      "avoid-escape"
+    ],
+    "semicolon": [
+      true,
+      "always"
+    ],
+    "trailing-comma": [
+      true,
+      "multiline"
+    ],
+    "triple-equals": [
+      true,
+      "allow-null-check"
+    ],
+    "typedef-whitespace": [
+      true,
+      {
+        "call-signature": "nospace",
+        "index-signature": "nospace",
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      }
+    ],
+    "variable-name": [
+      true,
+      "ban-keywords"
+    ],
+    "whitespace": [
+      true,
+      "check-branch",
+      "check-decl",
+      "check-operator",
+      "check-separator",
+      "check-type"
+    ]
+  }
+}