svg-path-commander 2.1.2 → 2.1.5

package/src/math/cubicTools.ts

@@ -1,124 +0,0 @@
-import { getBezierLength, minmaxC } from './bezier';
-import { type CubicCoordinates } from '../types';
-
-/**
- * Returns a point at a given length of a CubicBezier segment.
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param c1x the first control point X
- * @param c1y the first control point Y
- * @param c2x the second control point X
- * @param c2y the second control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @param t a [0-1] ratio
- * @returns the point at cubic-bezier segment length
- */
-const getPointAtCubicSegmentLength = ([x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates, t: number) => {
-  const t1 = 1 - t;
-  return {
-    x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x + t ** 3 * x2,
-    y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y + t ** 3 * y2,
-  };
-};
-
-/**
- * Returns the length of a CubicBezier segment.
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param c1x the first control point X
- * @param c1y the first control point Y
- * @param c2x the second control point X
- * @param c2y the second control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @returns the CubicBezier segment length
- */
-const getCubicLength = (
-  x1: number,
-  y1: number,
-  c1x: number,
-  c1y: number,
-  c2x: number,
-  c2y: number,
-  x2: number,
-  y2: number,
-) => {
-  return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);
-};
-
-/**
- * Returns the point along a CubicBezier segment at a given distance.
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param c1x the first control point X
- * @param c1y the first control point Y
- * @param c2x the second control point X
- * @param c2y the second control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @param distance the distance to look at
- * @returns the point at CubicBezier length
- */
-const getPointAtCubicLength = (
-  x1: number,
-  y1: number,
-  c1x: number,
-  c1y: number,
-  c2x: number,
-  c2y: number,
-  x2: number,
-  y2: number,
-  distance?: number,
-) => {
-  const distanceIsNumber = typeof distance === 'number';
-  let point = { x: x1, y: y1 };
-  /* istanbul ignore else @preserve */
-  if (distanceIsNumber) {
-    const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);
-    if (distance <= 0) {
-      // first point already defined
-    } else if (distance >= currentLength) {
-      point = { x: x2, y: y2 };
-    } else {
-      point = getPointAtCubicSegmentLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2], distance / currentLength);
-    }
-  }
-  return point;
-};
-
-/**
- * Returns the boundig box of a CubicBezier segment.
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param c1x the first control point X
- * @param c1y the first control point Y
- * @param c2x the second control point X
- * @param c2y the second control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @returns the point at CubicBezier length
- */
-const getCubicBBox = (
-  x1: number,
-  y1: number,
-  c1x: number,
-  c1y: number,
-  c2x: number,
-  c2y: number,
-  x2: number,
-  y2: number,
-) => {
-  const cxMinMax = minmaxC([x1, c1x, c2x, x2]);
-  const cyMinMax = minmaxC([y1, c1y, c2y, y2]);
-  return {
-    min: { x: cxMinMax[0], y: cyMinMax[0] },
-    max: { x: cxMinMax[1], y: cyMinMax[1] },
-  };
-};
-
-export { getCubicLength, getCubicBBox, getPointAtCubicLength, getPointAtCubicSegmentLength };

package/src/math/distanceSquareRoot.ts

@@ -1,15 +0,0 @@
-import { type PointTuple } from '../types';
-
-/**
- * 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: PointTuple, b: PointTuple) => {
-  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/lineTools.ts

@@ -1,69 +0,0 @@
-import midPoint from './midPoint';
-import distanceSquareRoot from './distanceSquareRoot';
-
-/**
- * Returns length for line segments (MoveTo, LineTo).
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @returns the line segment length
- */
-const getLineLength = (x1: number, y1: number, x2: number, y2: number) => {
-  return distanceSquareRoot([x1, y1], [x2, y2]);
-};
-
-/**
- * Returns a point along the line segments (MoveTo, LineTo).
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @param distance the distance to point in [0-1] range
- * @returns the point at length
- */
-const getPointAtLineLength = (x1: number, y1: number, x2: number, y2: number, distance?: number) => {
-  let point = { x: x1, y: y1 };
-
-  /* istanbul ignore else @preserve */
-  if (typeof distance === 'number') {
-    const length = distanceSquareRoot([x1, y1], [x2, y2]);
-    if (distance <= 0) {
-      point = { x: x1, y: y1 };
-    } else if (distance >= length) {
-      point = { x: x2, y: y2 };
-    } else {
-      const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);
-      point = { x, y };
-    }
-  }
-  return point;
-};
-
-/**
- * Returns bounding box for line segments (MoveTo, LineTo).
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @param distance the distance to point in [0-1] range
- * @returns the extrema for line segments
- */
-const getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {
-  const { min, max } = Math;
-  return {
-    min: {
-      x: min(x1, x2),
-      y: min(y1, y2),
-    },
-    max: {
-      x: max(x1, x2),
-      y: max(y1, y2),
-    },
-  };
-};
-
-export { getPointAtLineLength, getLineBBox, getLineLength };

package/src/math/midPoint.ts

@@ -1,18 +0,0 @@
-import { PointTuple } from '../types';
-
-/**
- * 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: PointTuple, b: PointTuple, t: number): PointTuple => {
-  const [ax, ay] = a;
-  const [bx, by] = b;
-  return [ax + (bx - ax) * t, ay + (by - ay) * t];
-};
-
-export default midPoint;

package/src/math/polygonTools.ts

@@ -1,48 +0,0 @@
-import distanceSquareRoot from './distanceSquareRoot';
-import { type PointTuple } from '../types';
-
-/**
- * d3-polygon-area
- * https://github.com/d3/d3-polygon
- *
- * Returns the area of a polygon.
- *
- * @param polygon an array of coordinates
- * @returns the polygon area
- */
-const polygonArea = (polygon: PointTuple[]) => {
-  const n = polygon.length;
-  let i = -1;
-  let a: PointTuple;
-  let b = polygon[n - 1];
-  let area = 0;
-
-  /* eslint-disable-next-line */
-  while (++i < n) {
-    a = b;
-    b = polygon[i];
-    area += a[1] * b[0] - a[0] * b[1];
-  }
-
-  return area / 2;
-};
-
-/**
- * d3-polygon-length
- * https://github.com/d3/d3-polygon
- *
- * Returns the perimeter of a polygon.
- *
- * @param polygon an array of coordinates
- * @returns the polygon length
- */
-const polygonLength = (polygon: PointTuple[]) => {
-  return polygon.reduce((length, point, i) => {
-    if (i) {
-      return length + distanceSquareRoot(polygon[i - 1], point);
-    }
-    return 0;
-  }, 0);
-};
-
-export { polygonArea, polygonLength };

package/src/math/quadTools.ts

@@ -1,100 +0,0 @@
-import { getBezierLength, minmaxQ } from './bezier';
-import { type QuadCoordinates } from '../types';
-
-/**
- * Returns the {x,y} coordinates of a point at a
- * given length of a quadratic-bezier segment.
- *
- * @see https://github.com/substack/point-at-length
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param cx the control point X
- * @param cy the control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @param t a [0-1] ratio
- * @returns the requested {x,y} coordinates
- */
-const getPointAtQuadSegmentLength = ([x1, y1, cx, cy, x2, y2]: QuadCoordinates, t: number) => {
-  const t1 = 1 - t;
-  return {
-    x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,
-    y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,
-  };
-};
-
-/**
- * Returns the length of a QuadraticBezier segment.
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param cx the control point X
- * @param cy the control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @returns the QuadraticBezier segment length
- */
-const getQuadLength = (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => {
-  return getBezierLength([x1, y1, cx, cy, x2, y2]);
-};
-
-/**
- * Returns the point along a QuadraticBezier segment at a given distance.
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param cx the control point X
- * @param cy the control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @param distance the distance to look at
- * @returns the point at QuadraticBezier length
- */
-const getPointAtQuadLength = (
-  x1: number,
-  y1: number,
-  cx: number,
-  cy: number,
-  x2: number,
-  y2: number,
-  distance?: number,
-) => {
-  const distanceIsNumber = typeof distance === 'number';
-  let point = { x: x1, y: y1 };
-
-  /* istanbul ignore else @preserve */
-  if (distanceIsNumber) {
-    const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);
-    if (distance <= 0) {
-      // first point already defined
-    } else if (distance >= currentLength) {
-      point = { x: x2, y: y2 };
-    } else {
-      point = getPointAtQuadSegmentLength([x1, y1, cx, cy, x2, y2], distance / currentLength);
-    }
-  }
-  return point;
-};
-
-/**
- * Returns the boundig box of a QuadraticBezier segment.
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param cx the control point X
- * @param cy the control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @returns the point at CubicBezier length
- */
-const getQuadBBox = (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => {
-  const cxMinMax = minmaxQ([x1, cx, x2]);
-  const cyMinMax = minmaxQ([y1, cy, y2]);
-  return {
-    min: { x: cxMinMax[0], y: cyMinMax[0] },
-    max: { x: cxMinMax[1], y: cyMinMax[1] },
-  };
-};
-
-export { getPointAtQuadSegmentLength, getQuadLength, getQuadBBox, getPointAtQuadLength };

package/src/math/rotateVector.ts

@@ -1,17 +0,0 @@
-/**
- * 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 { sin, cos } = Math;
-  const X = x * cos(rad) - y * sin(rad);
-  const Y = x * sin(rad) + y * cos(rad);
-  return { x: X, y: Y };
-};
-
-export default rotateVector;

package/src/math/roundTo.ts

@@ -1,7 +0,0 @@
-const roundTo = (n: number, round: number) => {
-  const pow = round >= 1 ? 10 ** round : 1;
-
-  return round > 0 ? Math.round(n * pow) / pow : Math.round(n);
-};
-
-export default roundTo;

package/src/options/options.ts

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

package/src/parser/error.ts

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

package/src/parser/finalizeSegment.ts

@@ -1,35 +0,0 @@
-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 relativeCommand = pathCommand.toLowerCase() as RelativeCommand;
-  const { data } = path;
-
-  while (data.length >= paramsCount[relativeCommand]) {
-    // overloaded `moveTo`
-    // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts
-    if (relativeCommand === 'm' && data.length > 2) {
-      path.segments.push([pathCommand as PathCommand | number].concat(data.splice(0, 2) as number[]) as PathSegment);
-      relativeCommand = 'l';
-      pathCommand = pathCommand === 'm' ? 'l' : 'L';
-    } else {
-      path.segments.push(
-        [pathCommand as PathCommand | number].concat(
-          data.splice(0, paramsCount[relativeCommand]) as number[],
-        ) as PathSegment,
-      );
-    }
-
-    if (!paramsCount[relativeCommand]) {
-      break;
-    }
-  }
-};
-export default finalizeSegment;

package/src/parser/invalidPathValue.ts

@@ -1,2 +0,0 @@
-const invalidPathValue = 'Invalid path value';
-export default invalidPathValue;

package/src/parser/isArcCommand.ts

@@ -1,11 +0,0 @@
-/**
- * Checks if the character is an A (arc-to) path command.
- *
- * @param code the character to check
- * @returns check result
- */
-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

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/isMoveCommand.ts

@@ -1,17 +0,0 @@
-/**
- * Checks if the character is a MoveTo command.
- *
- * @param code the character to check
- * @returns check result
- */
-const isMoveCommand = (code: number): code is 0x6d | 0x4d => {
-  // eslint-disable-next-line no-bitwise -- Impossible to satisfy
-  switch (code | 0x20) {
-    case 0x6d /* m */:
-    case 0x4d /* M */:
-      return true;
-    default:
-      return false;
-  }
-};
-export default isMoveCommand;

package/src/parser/isPathCommand.ts

@@ -1,28 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,16 +0,0 @@
-/** 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

@@ -1,14 +0,0 @@
-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.ts

@@ -1,33 +0,0 @@
-import scanSegment from './scanSegment';
-import skipSpaces from './skipSpaces';
-import PathParser from './pathParser';
-import type { PathArray } from '../types';
-
-/**
- * Parses a path string value and returns an array
- * of segments we like to call `pathArray`.
- *
- * @param pathInput the string to be parsed
- * @returns the resulted `pathArray` or error string
- */
-const parsePathString = <T extends PathArray>(pathInput: string | T) => {
-  if (typeof pathInput !== 'string') {
-    return pathInput.slice(0) as typeof pathInput;
-  }
-
-  const path = new PathParser(pathInput);
-
-  skipSpaces(path);
-
-  while (path.index < path.max && !path.err.length) {
-    scanSegment(path);
-  }
-
-  if (path?.err.length) {
-    throw TypeError(path.err);
-  }
-
-  return path.segments as PathArray;
-};
-
-export default parsePathString;

package/src/parser/pathParser.ts

@@ -1,29 +0,0 @@
-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: (string | number)[];
-  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 = '';
-  }
-}