svg-path-commander 1.0.5 → 2.0.0-alpha2

package/src/interface.ts

@@ -0,0 +1,129 @@
+import type { PathSegment } from './types';
+
+export interface SegmentProperties {
+  segment: PathSegment;
+  index: number;
+  length: number;
+  lengthAtSegment: number;
+  [key: string]: any;
+}
+
+export interface PointProperties {
+  closest: {
+    x: number;
+    y: number;
+  };
+  distance: number;
+  segment?: SegmentProperties;
+}
+
+export interface LineAttr {
+  type: 'line';
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  [key: string]: string | number;
+}
+export interface PolyAttr {
+  type: 'polygon' | 'polyline';
+  points: string;
+  [key: string]: string | number;
+}
+export interface CircleAttr {
+  type: 'circle';
+  cx: number;
+  cy: number;
+  r: number;
+  [key: string]: string | number;
+}
+export interface EllipseAttr {
+  type: 'ellipse';
+  cx: number;
+  cy: number;
+  rx: number;
+  ry: number;
+  [key: string]: string | number;
+}
+export interface RectAttr {
+  type: 'rect';
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+  rx: number;
+  ry: number;
+  [key: string]: string | number;
+}
+export interface GlyphAttr {
+  type: 'glyph';
+  d: string;
+  [key: string]: string | number;
+}
+
+export interface ShapeParams {
+  line: ['x1', 'y1', 'x2', 'y2'];
+  circle: ['cx', 'cy', 'r'];
+  ellipse: ['cx', 'cy', 'rx', 'ry'];
+  rect: ['width', 'height', 'x', 'y', 'rx', 'ry'];
+  polygon: ['points'];
+  polyline: ['points'];
+  glyph: ['d'];
+}
+
+export interface PathBBox {
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+  x2: number;
+  y2: number;
+  cx: number;
+  cy: number;
+  cz: number;
+}
+export interface SegmentLimits {
+  min: { x: number; y: number };
+  max: { x: number; y: number };
+}
+
+export interface ParserParams {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  x: number;
+  y: number;
+  qx: number | null;
+  qy: number | null;
+}
+
+export interface LengthFactory {
+  length: number;
+  point: { x: number; y: number };
+  min: { x: number; y: number };
+  max: { x: number; y: number };
+}
+
+export interface Options {
+  round: 'auto' | 'off' | number;
+  origin: number[];
+}
+
+export interface PathTransform {
+  s: PathSegment;
+  c: string;
+  x: number;
+  y: number;
+}
+
+export interface TransformObject {
+  translate: number | number[];
+  rotate: number | number[];
+  scale: number | number[];
+  skew: number | number[];
+  origin: number[];
+}
+
+export type TransformProps = keyof TransformObject;
+export type TransformEntries = [TransformProps, TransformObject[TransformProps]][];

package/src/math/distanceSquareRoot.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the square root of the distance
+ * between two given points.
+ *
+ * @param a the first point coordinates
+ * @param b the second point coordinates
+ * @returns the distance value
+ */
+const distanceSquareRoot = (a: [number, number], b: [number, number]): number => {
+  return Math.sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]));
+};
+
+export default distanceSquareRoot;

package/src/math/midPoint.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns the coordinates of a specified distance
+ * ratio between two points.
+ *
+ * @param a the first point coordinates
+ * @param b the second point coordinates
+ * @param t the ratio
+ * @returns the midpoint coordinates
+ */
+const midPoint = (a: [number, number], b: [number, number], t: number): [number, number] => {
+  const [ax, ay] = a;
+  const [bx, by] = b;
+  return [ax + (bx - ax) * t, ay + (by - ay) * t];
+};
+
+export default midPoint;

package/src/math/{polygonArea.js → polygonArea.ts}

@@ -4,10 +4,10 @@
  *
  * Returns the area of a polygon.
  *
- * @param {number[][]} polygon an array of coordinates
- * @returns {number} the polygon area
+ * @param polygon an array of coordinates
+ * @returns the polygon area
  */
-export default function polygonArea(polygon) {
+const polygonArea = (polygon: [number, number][]): number => {
   const n = polygon.length;
   let i = -1;
   let a;
@@ -22,4 +22,6 @@ export default function polygonArea(polygon) {
   }
 
   return area / 2;
-}
+};
+
+export default polygonArea;

package/src/math/{polygonLength.js → polygonLength.ts}

@@ -6,14 +6,16 @@ import distanceSquareRoot from './distanceSquareRoot';
  *
  * Returns the perimeter of a polygon.
  *
- * @param {[number,number][]} polygon an array of coordinates
+ * @param polygon an array of coordinates
  * @returns {number} the polygon length
  */
-export default function polygonLength(polygon) {
+const polygonLength = (polygon: [number, number][]): number => {
   return polygon.reduce((length, point, i) => {
     if (i) {
       return length + distanceSquareRoot(polygon[i - 1], point);
     }
     return 0;
   }, 0);
-}
+};
+
+export default polygonLength;

package/src/math/rotateVector.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns an {x,y} vector rotated by a given
+ * angle in radian.
+ *
+ * @param x the initial vector x
+ * @param y the initial vector y
+ * @param rad the radian vector angle
+ * @returns the rotated vector
+ */
+const rotateVector = (x: number, y: number, rad: number): { x: number; y: number } => {
+  const X = x * Math.cos(rad) - y * Math.sin(rad);
+  const Y = x * Math.sin(rad) + y * Math.cos(rad);
+  return { x: X, y: Y };
+};
+
+export default rotateVector;

package/src/options/options.ts

@@ -0,0 +1,9 @@
+import { Options } from '../interface';
+
+/** SVGPathCommander default options */
+const defaultOptions: Options = {
+  origin: [0, 0, 0],
+  round: 4,
+};
+
+export default defaultOptions;

package/src/parser/error.ts

@@ -0,0 +1,2 @@
+const error = 'SVGPathCommander Error';
+export default error;

package/src/parser/finalizeSegment.ts

@@ -0,0 +1,31 @@
+import paramsCount from './paramsCount';
+import PathParser from './pathParser';
+import type { PathCommand, PathSegment, RelativeCommand } from '../types';
+
+/**
+ * Breaks the parsing of a pathString once a segment is finalized.
+ *
+ * @param path the `PathParser` instance
+ */
+const finalizeSegment = (path: PathParser) => {
+  let pathCommand = path.pathValue[path.segmentStart] as PathCommand;
+  let LK = pathCommand.toLowerCase() as RelativeCommand;
+  const { data } = path;
+
+  while (data.length >= paramsCount[LK]) {
+    // overloaded `moveTo`
+    // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts
+    if (LK === 'm' && data.length > 2) {
+      path.segments.push([pathCommand, ...(data.splice(0, 2) as number[])] as PathSegment);
+      LK = 'l';
+      pathCommand = pathCommand === 'm' ? 'l' : 'L';
+    } else {
+      path.segments.push([pathCommand, ...(data.splice(0, paramsCount[LK]) as number[])] as PathSegment);
+    }
+
+    if (!paramsCount[LK]) {
+      break;
+    }
+  }
+};
+export default finalizeSegment;

package/src/parser/{isArcCommand.js → isArcCommand.ts}

@@ -1,10 +1,11 @@
 /**
  * Checks if the character is an A (arc-to) path command.
  *
- * @param {number} code the character to check
- * @returns {boolean} check result
+ * @param code the character to check
+ * @returns check result
  */
-export default function isArcCommand(code) {
+const isArcCommand = (code: number): code is 0x61 => {
   // eslint-disable-next-line no-bitwise -- Impossible to satisfy
   return (code | 0x20) === 0x61;
-}
+};
+export default isArcCommand;

package/src/parser/isDigit.ts

@@ -0,0 +1,12 @@
+import { DigitNumber } from '../types';
+
+/**
+ * Checks if a character is a digit.
+ *
+ * @param code the character to check
+ * @returns check result
+ */
+const isDigit = (code: number): code is DigitNumber => {
+  return code >= 48 && code <= 57; // 0..9
+};
+export default isDigit;

package/src/parser/isDigitStart.ts

@@ -0,0 +1,14 @@
+import isDigit from './isDigit';
+import type { DigitNumber } from '../types';
+
+/**
+ * Checks if the character is or belongs to a number.
+ * [0-9]|+|-|.
+ *
+ * @param code the character to check
+ * @returns check result
+ */
+const isDigitStart = (code: number): code is DigitNumber | 0x2b | 0x2d | 0x2e => {
+  return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ || code === 0x2d /* - */ || code === 0x2e; /* . */
+};
+export default isDigitStart;

package/src/parser/isPathCommand.ts

@@ -0,0 +1,28 @@
+import type { PathCommandNumber } from '../types';
+
+/**
+ * Checks if the character is a path command.
+ *
+ * @param code the character to check
+ * @returns check result
+ */
+const isPathCommand = (code: number): code is PathCommandNumber => {
+  // eslint-disable-next-line no-bitwise -- Impossible to satisfy
+  switch (code | 0x20) {
+    case 0x6d /* m */:
+    case 0x7a /* z */:
+    case 0x6c /* l */:
+    case 0x68 /* h */:
+    case 0x76 /* v */:
+    case 0x63 /* c */:
+    case 0x73 /* s */:
+    case 0x71 /* q */:
+    case 0x74 /* t */:
+    case 0x61 /* a */:
+      // case 0x72/* r */:
+      return true;
+    default:
+      return false;
+  }
+};
+export default isPathCommand;

package/src/parser/isSpace.ts

@@ -0,0 +1,23 @@
+import type { SpaceNumber } from '../types';
+
+/**
+ * Checks if the character is a space.
+ *
+ * @param ch the character to check
+ * @returns check result
+ */
+
+const isSpace = (ch: number): ch is SpaceNumber => {
+  const allSpaces = [
+    // Special spaces
+    0x1680, 0x180e, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200a, 0x202f,
+    0x205f, 0x3000, 0xfeff,
+    // Line terminators
+    0x0a, 0x0d, 0x2028, 0x2029,
+    // White spaces
+    0x20, 0x09, 0x0b, 0x0c, 0xa0,
+  ];
+
+  return allSpaces.includes(ch);
+};
+export default isSpace;

package/src/parser/paramsCount.ts

@@ -0,0 +1,16 @@
+/** Segment params length */
+const paramsCount = {
+  a: 7,
+  c: 6,
+  h: 1,
+  l: 2,
+  m: 2,
+  r: 4,
+  q: 4,
+  s: 4,
+  t: 2,
+  v: 1,
+  z: 0,
+};
+
+export default paramsCount;

package/src/parser/paramsParser.ts

@@ -0,0 +1,14 @@
+import type { ParserParams } from '../interface';
+
+const paramsParser: ParserParams = {
+  x1: 0,
+  y1: 0,
+  x2: 0,
+  y2: 0,
+  x: 0,
+  y: 0,
+  qx: null,
+  qy: null,
+};
+
+export default paramsParser;

package/src/parser/{parsePathString.js → parsePathString.ts}

@@ -1,19 +1,19 @@
 import scanSegment from './scanSegment';
 import skipSpaces from './skipSpaces';
-import clonePath from '../process/clonePath';
 import PathParser from './pathParser';
 import isPathArray from '../util/isPathArray';
+import type { PathArray } from '../types';
 
 /**
  * Parses a path string value and returns an array
  * of segments we like to call `pathArray`.
  *
- * @param {SVGPath.pathArray | string} pathInput the string to be parsed
- * @returns {SVGPath.pathArray | string} the resulted `pathArray` or error string
+ * @param pathInput the string to be parsed
+ * @returns the resulted `pathArray` or error string
  */
-export default function parsePathString(pathInput) {
+const parsePathString = (pathInput: string | PathArray): PathArray => {
   if (isPathArray(pathInput)) {
-    return clonePath(pathInput);
+    return [...pathInput];
   }
 
   const path = new PathParser(pathInput);
@@ -24,5 +24,11 @@ export default function parsePathString(pathInput) {
     scanSegment(path);
   }
 
-  return path.err ? path.err : path.segments;
-}
+  if (path.err && path.err.length) {
+    throw TypeError(path.err);
+  }
+
+  return path.segments as PathArray;
+};
+
+export default parsePathString;

package/src/parser/pathParser.ts

@@ -0,0 +1,29 @@
+import type { PathArray, PathSegment } from '../types';
+
+/**
+ * The `PathParser` is used by the `parsePathString` static method
+ * to generate a `pathArray`.
+ *
+ * @param pathString
+ */
+export default class PathParser {
+  declare segments: PathArray | PathSegment[];
+  declare pathValue: string;
+  declare max: number;
+  declare index: number;
+  declare param: number;
+  declare segmentStart: number;
+  declare data: any[];
+  declare err: string;
+
+  constructor(pathString: string) {
+    this.segments = [];
+    this.pathValue = pathString;
+    this.max = pathString.length;
+    this.index = 0;
+    this.param = 0.0;
+    this.segmentStart = 0;
+    this.data = [];
+    this.err = '';
+  }
+}

package/src/parser/{scanFlag.js → scanFlag.ts}

@@ -1,26 +1,29 @@
 import error from './error';
+import type PathParser from './pathParser';
 
 /**
  * Validates an A (arc-to) specific path command value.
  * Usually a `large-arc-flag` or `sweep-flag`.
  *
- * @param {SVGPath.PathParser} path the `PathParser` instance
+ * @param path the `PathParser` instance
  */
-export default function scanFlag(path) {
+const scanFlag = (path: PathParser) => {
   const { index, pathValue } = path;
   const code = pathValue.charCodeAt(index);
 
-  if (code === 0x30/* 0 */) {
+  if (code === 0x30 /* 0 */) {
     path.param = 0;
     path.index += 1;
     return;
   }
 
-  if (code === 0x31/* 1 */) {
+  if (code === 0x31 /* 1 */) {
     path.param = 1;
     path.index += 1;
     return;
   }
 
   path.err = `${error}: invalid Arc flag "${pathValue[index]}", expecting 0 or 1 at index ${index}`;
-}
+};
+
+export default scanFlag;

package/src/parser/{scanParam.js → scanParam.ts}

@@ -1,14 +1,15 @@
 import isDigit from './isDigit';
 import invalidPathValue from './invalidPathValue';
 import error from './error';
+import type PathParser from './pathParser';
 
 /**
  * Validates every character of the path string,
  * every path command, negative numbers or floating point numbers.
  *
- * @param {SVGPath.PathParser} path the `PathParser` instance
+ * @param path the `PathParser` instance
  */
-export default function scanParam(path) {
+const scanParam = (path: PathParser) => {
   const { max, pathValue, index: start } = path;
   let index = start;
   let zeroFirst = false;
@@ -18,13 +19,12 @@ export default function scanParam(path) {
   let ch;
 
   if (index >= max) {
-    // path.err = 'SvgPath: missed param (at pos ' + index + ')';
     path.err = `${error}: ${invalidPathValue} at index ${index}, "pathValue" is missing param`;
     return;
   }
   ch = pathValue.charCodeAt(index);
 
-  if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
+  if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {
     index += 1;
     // ch = (index < max) ? pathValue.charCodeAt(index) : 0;
     ch = pathValue.charCodeAt(index);
@@ -32,14 +32,14 @@ export default function scanParam(path) {
 
   // This logic is shamelessly borrowed from Esprima
   // https://github.com/ariya/esprimas
-  if (!isDigit(ch) && ch !== 0x2E/* . */) {
+  if (!isDigit(ch) && ch !== 0x2e /* . */) {
     // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';
     path.err = `${error}: ${invalidPathValue} at index ${index}, "${pathValue[index]}" is not a number`;
     return;
   }
 
-  if (ch !== 0x2E/* . */) {
-    zeroFirst = (ch === 0x30/* 0 */);
+  if (ch !== 0x2e /* . */) {
+    zeroFirst = ch === 0x30 /* 0 */;
     index += 1;
 
     ch = pathValue.charCodeAt(index);
@@ -62,7 +62,7 @@ export default function scanParam(path) {
     ch = pathValue.charCodeAt(index);
   }
 
-  if (ch === 0x2E/* . */) {
+  if (ch === 0x2e /* . */) {
     hasDot = true;
     index += 1;
     while (isDigit(pathValue.charCodeAt(index))) {
@@ -73,7 +73,7 @@ export default function scanParam(path) {
     ch = pathValue.charCodeAt(index);
   }
 
-  if (ch === 0x65/* e */ || ch === 0x45/* E */) {
+  if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {
     if (hasDot && !hasCeiling && !hasDecimal) {
       path.err = `${error}: ${invalidPathValue} at index ${index}, "${pathValue[index]}" invalid float exponent`;
       return;
@@ -83,7 +83,7 @@ export default function scanParam(path) {
 
     ch = pathValue.charCodeAt(index);
 
-    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
+    if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {
       index += 1;
     }
     if (index < max && isDigit(pathValue.charCodeAt(index))) {
@@ -98,4 +98,5 @@ export default function scanParam(path) {
 
   path.index = index;
   path.param = +path.pathValue.slice(start, index);
-}
+};
+export default scanParam;

package/src/parser/{scanSegment.js → scanSegment.ts}

@@ -9,16 +9,19 @@ import isArcCommand from './isArcCommand';
 import invalidPathValue from './invalidPathValue';
 import error from './error';
 
+import type PathParser from './pathParser';
+import { RelativeCommand } from '../types';
+
 /**
  * Scans every character in the path string to determine
  * where a segment starts and where it ends.
  *
- * @param {SVGPath.PathParser} path the `PathParser` instance
+ * @param path the `PathParser` instance
  */
-export default function scanSegment(path) {
+const scanSegment = (path: PathParser) => {
   const { max, pathValue, index } = path;
   const cmdCode = pathValue.charCodeAt(index);
-  const reqParams = paramCounts[pathValue[index].toLowerCase()];
+  const reqParams = paramCounts[pathValue[index].toLowerCase() as RelativeCommand];
 
   path.segmentStart = index;
 
@@ -51,7 +54,7 @@ export default function scanSegment(path) {
       skipSpaces(path);
 
       // after ',' param is mandatory
-      if (path.index < max && pathValue.charCodeAt(path.index) === 0x2C/* , */) {
+      if (path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */) {
         path.index += 1;
         skipSpaces(path);
       }
@@ -68,4 +71,5 @@ export default function scanSegment(path) {
   }
 
   finalizeSegment(path);
-}
+};
+export default scanSegment;

package/src/parser/{skipSpaces.js → skipSpaces.ts}

@@ -1,15 +1,17 @@
 import isSpace from './isSpace';
+import type PathParser from './pathParser';
 
 /**
  * Points the parser to the next character in the
  * path string every time it encounters any kind of
  * space character.
  *
- * @param {SVGPath.PathParser} path the `PathParser` instance
+ * @param path the `PathParser` instance
  */
-export default function skipSpaces(path) {
+const skipSpaces = (path: PathParser) => {
   const { pathValue, max } = path;
   while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {
     path.index += 1;
   }
-}
+};
+export default skipSpaces;