svg-path-commander 1.0.5 → 2.0.0-alpha2

package/src/util/getPointAtLength.ts

@@ -0,0 +1,14 @@
+import type { PathArray } from '../types';
+import pathLengthFactory from './pathLengthFactory';
+
+/**
+ * Returns [x,y] coordinates of a point at a given length of a shape.
+ *
+ * @param pathInput the `pathArray` to look into
+ * @param distance the length of the shape to look at
+ * @returns the requested {x, y} point coordinates
+ */
+const getPointAtLength = (pathInput: string | PathArray, distance: number): { x: number; y: number } => {
+  return pathLengthFactory(pathInput, distance).point;
+};
+export default getPointAtLength;

package/src/util/{getPropertiesAtLength.js → getPropertiesAtLength.ts}

@@ -1,3 +1,5 @@
+import type { PathArray, PathSegment } from '../types';
+import type { SegmentProperties } from '../interface';
 import parsePathString from '../parser/parsePathString';
 import getTotalLength from './getTotalLength';
 
@@ -5,54 +7,61 @@ import getTotalLength from './getTotalLength';
  * Returns the segment, its index and length as well as
  * the length to that segment at a given length in a path.
  *
- * @param {string | SVGPath.pathArray} pathInput target `pathArray`
- * @param {number=} distance the given length
- * @returns {SVGPath.segmentProperties=} the requested properties
+ * @param pathInput target `pathArray`
+ * @param distance the given length
+ * @returns the requested properties
  */
-export default function getPropertiesAtLength(pathInput, distance) {
+const getPropertiesAtLength = (pathInput: string | PathArray, distance?: number): SegmentProperties => {
   const pathArray = parsePathString(pathInput);
 
-  if (typeof pathArray === 'string') {
-    throw TypeError(pathArray);
-  }
-
-  let pathTemp = [...pathArray];
+  let pathTemp = [...pathArray] as PathArray;
   let pathLength = getTotalLength(pathTemp);
   let index = pathTemp.length - 1;
   let lengthAtSegment = 0;
   let length = 0;
-  let segment = pathArray[0];
-  const [x, y] = segment.slice(-2);
+  let segment = pathArray[0] as PathSegment;
+  const [x, y] = segment.slice(-2) as [number, number];
   const point = { x, y };
 
   // If the path is empty, return 0.
   if (index <= 0 || !distance || !Number.isFinite(distance)) {
     return {
-      segment, index: 0, length, point, lengthAtSegment,
+      segment,
+      index: 0,
+      length,
+      point,
+      lengthAtSegment,
     };
   }
 
   if (distance >= pathLength) {
-    pathTemp = pathArray.slice(0, -1);
+    pathTemp = pathArray.slice(0, -1) as PathArray;
     lengthAtSegment = getTotalLength(pathTemp);
     length = pathLength - lengthAtSegment;
     return {
-      segment: pathArray[index], index, length, lengthAtSegment,
+      segment: pathArray[index],
+      index,
+      length,
+      lengthAtSegment,
     };
   }
 
-  const segments = [];
+  const segments = [] as SegmentProperties[];
   while (index > 0) {
     segment = pathTemp[index];
-    pathTemp = pathTemp.slice(0, -1);
+    pathTemp = pathTemp.slice(0, -1) as PathArray;
     lengthAtSegment = getTotalLength(pathTemp);
     length = pathLength - lengthAtSegment;
     pathLength = lengthAtSegment;
     segments.push({
-      segment, index, length, lengthAtSegment,
+      segment,
+      index,
+      length,
+      lengthAtSegment,
     });
     index -= 1;
   }
 
-  return segments.find(({ lengthAtSegment: l }) => l <= distance);
-}
+  return segments.find(({ lengthAtSegment: l }) => l <= distance) as SegmentProperties;
+};
+export default getPropertiesAtLength;

package/src/util/{getPropertiesAtPoint.js → getPropertiesAtPoint.ts}

@@ -1,3 +1,5 @@
+import type { PathArray } from '../types';
+import type { PointProperties } from '../interface';
 import getPointAtLength from './getPointAtLength';
 import getPropertiesAtLength from './getPropertiesAtLength';
 import getTotalLength from './getTotalLength';
@@ -7,26 +9,26 @@ import normalizePath from '../process/normalizePath';
 /**
  * Returns the point and segment in path closest to a given point as well as
  * the distance to the path stroke.
+ *
  * @see https://bl.ocks.org/mbostock/8027637
  *
- * @param {string | SVGPath.pathArray} pathInput target `pathArray`
- * @param {{x: number, y: number}} point the given point
- * @returns {SVGPath.pointProperties} the requested properties
+ * @param pathInput target `pathArray`
+ * @param point the given point
+ * @returns the requested properties
  */
-export default function getPropertiesAtPoint(pathInput, point) {
-  const path = (parsePathString(pathInput));
+const getPropertiesAtPoint = (pathInput: string | PathArray, point: { x: number; y: number }): PointProperties => {
+  const path = parsePathString(pathInput);
   const normalPath = normalizePath(path);
   const pathLength = getTotalLength(path);
-  /** @param {{x: number, y: number}} p */
-  const distanceTo = (p) => {
+  const distanceTo = (p: { x: number; y: number }) => {
     const dx = p.x - point.x;
     const dy = p.y - point.y;
     return dx * dx + dy * dy;
   };
   let precision = 8;
-  let scan;
+  let scan: { x: number; y: number };
+  let closest = { x: 0, y: 0 }; // make TS happy
   let scanDistance = 0;
-  let closest;
   let bestLength = 0;
   let bestDistance = Infinity;
 
@@ -43,8 +45,8 @@ export default function getPropertiesAtPoint(pathInput, point) {
 
   // binary search for precise estimate
   precision /= 2;
-  let before;
-  let after;
+  let before: { x: number; y: number };
+  let after: { x: number; y: number };
   let beforeLength = 0;
   let afterLength = 0;
   let beforeDistance = 0;
@@ -74,4 +76,6 @@ export default function getPropertiesAtPoint(pathInput, point) {
   const distance = Math.sqrt(bestDistance);
 
   return { closest, distance, segment };
-}
+};
+
+export default getPropertiesAtPoint;

package/src/util/getSegmentAtLength.ts

@@ -0,0 +1,15 @@
+import type { PathArray, PathSegment } from '../types';
+import getPropertiesAtLength from './getPropertiesAtLength';
+
+/**
+ * Returns the segment at a given length.
+ *
+ * @param pathInput the target `pathArray`
+ * @param distance the distance in path to look at
+ * @returns the requested segment
+ */
+const getSegmentAtLength = (pathInput: string | PathArray, distance?: number): PathSegment | undefined => {
+  return getPropertiesAtLength(pathInput, distance).segment;
+};
+
+export default getSegmentAtLength;

package/src/util/getSegmentOfPoint.ts

@@ -0,0 +1,18 @@
+import type { SegmentProperties } from '../interface';
+import type { PathArray } from '../types';
+import getPropertiesAtPoint from './getPropertiesAtPoint';
+
+/**
+ * Returns the path segment which contains a given point.
+ *
+ * @param path the `pathArray` to look into
+ * @param point the point of the shape to look for
+ * @returns the requested segment
+ */
+const getSegmentOfPoint = (
+  path: string | PathArray,
+  point: { x: number; y: number },
+): SegmentProperties | undefined => {
+  return getPropertiesAtPoint(path, point).segment;
+};
+export default getSegmentOfPoint;

package/src/util/{getTotalLength.js → getTotalLength.ts}

@@ -1,3 +1,4 @@
+import type { PathArray } from '../types';
 import pathLengthFactory from './pathLengthFactory';
 
 /**
@@ -6,9 +7,10 @@ import pathLengthFactory from './pathLengthFactory';
  * The `normalizePath` version is lighter, faster, more efficient and more accurate
  * with paths that are not `curveArray`.
  *
- * @param {string | SVGPath.pathArray} pathInput the target `pathArray`
- * @returns {number} the shape total length
+ * @param pathInput the target `pathArray`
+ * @returns the shape total length
  */
-export default function getTotalLength(pathInput) {
+const getTotalLength = (pathInput: string | PathArray): number => {
   return pathLengthFactory(pathInput).length;
-}
+};
+export default getTotalLength;

package/src/util/isAbsoluteArray.ts

@@ -0,0 +1,18 @@
+import type { AbsoluteArray } from '../types';
+import isPathArray from './isPathArray';
+
+/**
+ * Iterates an array to check if it's a `pathArray`
+ * with all absolute values.
+ *
+ * @param path the `pathArray` to be checked
+ * @returns iteration result
+ */
+const isAbsoluteArray = (path: unknown): path is AbsoluteArray => {
+  return (
+    isPathArray(path) &&
+    // `isPathArray` also checks if it's `Array`
+    path.every(([x]) => x === x.toUpperCase())
+  );
+};
+export default isAbsoluteArray;

package/src/util/{isCurveArray.js → isCurveArray.ts}

@@ -1,13 +1,15 @@
+import { CurveArray } from '../types';
 import isNormalizedArray from './isNormalizedArray';
 
 /**
  * Iterates an array to check if it's a `pathArray`
  * with all C (cubic bezier) segments.
  *
- * @param {string | SVGPath.pathArray} path the `Array` to be checked
- * @returns {boolean} iteration result
+ * @param path the `Array` to be checked
+ * @returns iteration result
  */
-export default function isCurveArray(path) {
+const isCurveArray = (path: unknown): path is CurveArray => {
   // `isPathArray` also checks if it's `Array`
   return isNormalizedArray(path) && path.every(([pc]) => 'MC'.includes(pc));
-}
+};
+export default isCurveArray;

package/src/util/{isNormalizedArray.js → isNormalizedArray.ts}

@@ -1,3 +1,4 @@
+import type { NormalArray } from '../types';
 import isAbsoluteArray from './isAbsoluteArray';
 
 /**
@@ -8,7 +9,8 @@ import isAbsoluteArray from './isAbsoluteArray';
  * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
  * @returns {boolean} iteration result
  */
-export default function isNormalizedArray(path) {
+const isNormalizedArray = (path: unknown): path is NormalArray => {
   // `isAbsoluteArray` also checks if it's `Array`
   return isAbsoluteArray(path) && path.every(([pc]) => 'ACLMQZ'.includes(pc));
-}
+};
+export default isNormalizedArray;

package/src/util/isPathArray.ts

@@ -0,0 +1,19 @@
+import type { PathArray, PathSegment, RelativeCommand } from '../types';
+import paramsCount from '../parser/paramsCount';
+
+/**
+ * Iterates an array to check if it's an actual `pathArray`.
+ *
+ * @param path the `pathArray` to be checked
+ * @returns iteration result
+ */
+const isPathArray = (path: unknown): path is PathArray => {
+  return (
+    Array.isArray(path) &&
+    path.every((seg: PathSegment) => {
+      const lk = seg[0].toLowerCase() as RelativeCommand;
+      return paramsCount[lk] === seg.length - 1 && 'achlmqstvz'.includes(lk);
+    })
+  );
+};
+export default isPathArray;

package/src/util/isPointInStroke.ts

@@ -0,0 +1,15 @@
+import type { PathArray } from '../types';
+import getPropertiesAtPoint from './getPropertiesAtPoint';
+
+/**
+ * Checks if a given point is in the stroke of a path.
+ *
+ * @param pathInput target path
+ * @param point the given `{x,y}` point
+ * @returns the query result
+ */
+const isPointInStroke = (pathInput: string | PathArray, point: { x: number; y: number }) => {
+  const { distance } = getPropertiesAtPoint(pathInput, point);
+  return Math.abs(distance) < 0.001; // 0.01 might be more permissive
+};
+export default isPointInStroke;

package/src/util/isRelativeArray.ts

@@ -0,0 +1,18 @@
+import type { RelativeArray } from '../types';
+import isPathArray from './isPathArray';
+
+/**
+ * Iterates an array to check if it's a `pathArray`
+ * with relative values.
+ *
+ * @param path the `pathArray` to be checked
+ * @returns iteration result
+ */
+const isRelativeArray = (path: unknown): path is RelativeArray => {
+  return (
+    isPathArray(path) &&
+    // `isPathArray` checks if it's `Array`
+    path.slice(1).every(([pc]) => pc === pc.toLowerCase())
+  );
+};
+export default isRelativeArray;

package/src/util/{isValidPath.js → isValidPath.ts}

@@ -6,10 +6,10 @@ import PathParser from '../parser/pathParser';
  * Parses a path string value to determine its validity
  * then returns true if it's valid or false otherwise.
  *
- * @param {string} pathString the path string to be parsed
- * @returns {boolean} the path string validity
+ * @param pathString the path string to be parsed
+ * @returns the path string validity
  */
-export default function isValidPath(pathString) {
+const isValidPath = (pathString: string) => {
   if (typeof pathString !== 'string') {
     return false;
   }
@@ -23,4 +23,5 @@ export default function isValidPath(pathString) {
   }
 
   return !path.err.length && 'mM'.includes(path.segments[0][0]);
-}
+};
+export default isValidPath;

package/src/util/{pathLengthFactory.js → pathLengthFactory.ts}

@@ -1,5 +1,6 @@
+import type { MSegment, PathArray } from '../types';
+import type { LengthFactory } from '../interface';
 import normalizePath from '../process/normalizePath';
-
 import segmentLineFactory from './segmentLineFactory';
 import segmentArcFactory from './segmentArcFactory';
 import segmentCubicFactory from './segmentCubicFactory';
@@ -10,23 +11,23 @@ import segmentQuadFactory from './segmentQuadFactory';
  * of a shape, the shape total length and
  * the shape minimum and maximum {x,y} coordinates.
  *
- * @param {string | SVGPath.pathArray} pathInput the `pathArray` to look into
- * @param {number=} distance the length of the shape to look at
- * @returns {SVGPath.lengthFactory} the path length, point, min & max
+ * @param pathInput the `pathArray` to look into
+ * @param distance the length of the shape to look at
+ * @returns the path length, point, min & max
  */
-export default function pathLengthFactory(pathInput, distance) {
+const pathLengthFactory = (pathInput: string | PathArray, distance?: number): LengthFactory => {
   const path = normalizePath(pathInput);
   const distanceIsNumber = typeof distance === 'number';
   let isM;
-  let data = [];
+  let data = [] as number[];
   let pathCommand;
   let x = 0;
   let y = 0;
   let mx = 0;
   let my = 0;
   let seg;
-  let MIN = [];
-  let MAX = [];
+  let MIN = [] as { x: number; y: number }[];
+  let MAX = [] as { x: number; y: number }[];
   let length = 0;
   let min = { x: 0, y: 0 };
   let max = min;
@@ -38,13 +39,13 @@ export default function pathLengthFactory(pathInput, distance) {
     seg = path[i];
     [pathCommand] = seg;
     isM = pathCommand === 'M';
-    data = !isM ? [x, y, ...seg.slice(1)] : data;
+    data = !isM ? [x, y, ...(seg.slice(1) as number[])] : data;
 
     // this segment is always ZERO
     /* istanbul ignore else */
     if (isM) {
       // remember mx, my for Z
-      [, mx, my] = seg;
+      [, mx, my] = seg as MSegment;
       min = { x: mx, y: my };
       max = min;
       length = 0;
@@ -53,26 +54,31 @@ export default function pathLengthFactory(pathInput, distance) {
         POINT = min;
       }
     } else if (pathCommand === 'L') {
-      ({
-        length, min, max, point,
-      } = segmentLineFactory(...data, (distance || 0) - LENGTH));
+      ({ length, min, max, point } = segmentLineFactory(
+        ...(data as [number, number, number, number]),
+        (distance || 0) - LENGTH,
+      ));
     } else if (pathCommand === 'A') {
-      ({
-        length, min, max, point,
-      } = segmentArcFactory(...data, (distance || 0) - LENGTH));
+      ({ length, min, max, point } = segmentArcFactory(
+        ...(data as [number, number, number, number, number, number, number, number, number]),
+        (distance || 0) - LENGTH,
+      ));
     } else if (pathCommand === 'C') {
-      ({
-        length, min, max, point,
-      } = segmentCubicFactory(...data, (distance || 0) - LENGTH));
+      ({ length, min, max, point } = segmentCubicFactory(
+        ...(data as [number, number, number, number, number, number, number]),
+        (distance || 0) - LENGTH,
+      ));
     } else if (pathCommand === 'Q') {
-      ({
-        length, min, max, point,
-      } = segmentQuadFactory(...data, (distance || 0) - LENGTH));
+      ({ length, min, max, point } = segmentQuadFactory(
+        ...(data as [number, number, number, number, number, number]),
+        (distance || 0) - LENGTH,
+      ));
     } else if (pathCommand === 'Z') {
       data = [x, y, mx, my];
-      ({
-        length, min, max, point,
-      } = segmentLineFactory(...data, (distance || 0) - LENGTH));
+      ({ length, min, max, point } = segmentLineFactory(
+        ...(data as [number, number, number, number]),
+        (distance || 0) - LENGTH,
+      ));
     }
 
     if (distanceIsNumber && LENGTH < distance && LENGTH + length >= distance) {
@@ -83,7 +89,7 @@ export default function pathLengthFactory(pathInput, distance) {
     MIN = [...MIN, min];
     LENGTH += length;
 
-    [x, y] = pathCommand !== 'Z' ? seg.slice(-2) : [mx, my];
+    [x, y] = pathCommand !== 'Z' ? (seg.slice(-2) as [number, number]) : [mx, my];
   }
 
   // native `getPointAtLength` behavior when the given distance
@@ -96,12 +102,13 @@ export default function pathLengthFactory(pathInput, distance) {
     length: LENGTH,
     point: POINT,
     min: {
-      x: Math.min(...MIN.map((n) => n.x)),
-      y: Math.min(...MIN.map((n) => n.y)),
+      x: Math.min(...MIN.map(n => n.x)),
+      y: Math.min(...MIN.map(n => n.y)),
     },
     max: {
-      x: Math.max(...MAX.map((n) => n.x)),
-      y: Math.max(...MAX.map((n) => n.y)),
+      x: Math.max(...MAX.map(n => n.x)),
+      y: Math.max(...MAX.map(n => n.y)),
     },
   };
-}
+};
+export default pathLengthFactory;