svg-path-commander 2.0.10 → 2.1.1

package/src/util/segmentArcFactory.ts

@@ -1,219 +0,0 @@
-import type { LengthFactory } from '../interface';
-import segmentLineFactory from './segmentLineFactory';
-import distanceSquareRoot from '../math/distanceSquareRoot';
-
-/**
- * Returns an angle value between two points.
- *
- * @param v0
- * @param v1
- * @returns a number representing an angle
- */
-const angleBetween = (v0: { x: number; y: number }, v1: { x: number; y: number }): number => {
-  const { x: v0x, y: v0y } = v0;
-  const { x: v1x, y: v1y } = v1;
-  const p = v0x * v1x + v0y * v1y;
-  const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));
-  const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;
-  const angle = sign * Math.acos(p / n);
-
-  return angle;
-};
-
-/**
- * Returns a {x,y} point at a given length, the total length and
- * the minimum and maximum {x,y} coordinates of a C (cubic-bezier) segment.
- *
- * @see https://github.com/MadLittleMods/svg-curve-lib/blob/master/src/js/svg-curve-lib.js
- *
- * @param x1 the starting x position
- * @param y1 the starting y position
- * @param RX x-radius of the arc
- * @param RY y-radius of the arc
- * @param angle x-axis-rotation of the arc
- * @param LAF large-arc-flag of the arc
- * @param SF sweep-flag of the arc
- * @param x the ending x position
- * @param y the ending y position
- * @param t the point distance
- * @returns the requested point
- */
-const getPointAtArcSegmentLength = (
-  x1: number,
-  y1: number,
-  RX: number,
-  RY: number,
-  angle: number,
-  LAF: number,
-  SF: number,
-  x: number,
-  y: number,
-  t: number,
-): { x: number; y: number } => {
-  const { abs, sin, cos, sqrt, PI } = Math;
-  let rx = abs(RX);
-  let ry = abs(RY);
-  const xRot = ((angle % 360) + 360) % 360;
-  const xRotRad = xRot * (PI / 180);
-
-  if (x1 === x && y1 === y) {
-    return { x: x1, y: y1 };
-  }
-
-  if (rx === 0 || ry === 0) {
-    return segmentLineFactory(x1, y1, x, y, t).point;
-  }
-
-  const dx = (x1 - x) / 2;
-  const dy = (y1 - y) / 2;
-
-  const transformedPoint = {
-    x: cos(xRotRad) * dx + sin(xRotRad) * dy,
-    y: -sin(xRotRad) * dx + cos(xRotRad) * dy,
-  };
-
-  const radiiCheck = transformedPoint.x ** 2 / rx ** 2 + transformedPoint.y ** 2 / ry ** 2;
-
-  if (radiiCheck > 1) {
-    rx *= sqrt(radiiCheck);
-    ry *= sqrt(radiiCheck);
-  }
-
-  const cSquareNumerator = rx ** 2 * ry ** 2 - rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;
-
-  const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 + ry ** 2 * transformedPoint.x ** 2;
-
-  let cRadicand = cSquareNumerator / cSquareRootDenom;
-  cRadicand = cRadicand < 0 ? 0 : cRadicand;
-  const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);
-  const transformedCenter = {
-    x: cCoef * ((rx * transformedPoint.y) / ry),
-    y: cCoef * (-(ry * transformedPoint.x) / rx),
-  };
-
-  const center = {
-    x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y + (x1 + x) / 2,
-    y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y + (y1 + y) / 2,
-  };
-
-  const startVector = {
-    x: (transformedPoint.x - transformedCenter.x) / rx,
-    y: (transformedPoint.y - transformedCenter.y) / ry,
-  };
-
-  const startAngle = angleBetween({ x: 1, y: 0 }, startVector);
-
-  const endVector = {
-    x: (-transformedPoint.x - transformedCenter.x) / rx,
-    y: (-transformedPoint.y - transformedCenter.y) / ry,
-  };
-
-  let sweepAngle = angleBetween(startVector, endVector);
-  if (!SF && sweepAngle > 0) {
-    sweepAngle -= 2 * PI;
-  } else if (SF && sweepAngle < 0) {
-    sweepAngle += 2 * PI;
-  }
-  sweepAngle %= 2 * PI;
-
-  const alpha = startAngle + sweepAngle * t;
-  const ellipseComponentX = rx * cos(alpha);
-  const ellipseComponentY = ry * sin(alpha);
-
-  const point = {
-    x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY + center.x,
-    y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY + center.y,
-  };
-
-  // to be used later
-  // point.ellipticalArcStartAngle = startAngle;
-  // point.ellipticalArcEndAngle = startAngle + sweepAngle;
-  // point.ellipticalArcAngle = alpha;
-
-  // point.ellipticalArcCenter = center;
-  // point.resultantRx = rx;
-  // point.resultantRy = ry;
-
-  return point;
-};
-
-/**
- * Returns a {x,y} point at a given length, the total length and
- * the shape minimum and maximum {x,y} coordinates of an A (arc-to) segment.
- *
- * @param X1 the starting x position
- * @param Y1 the starting y position
- * @param RX x-radius of the arc
- * @param RY y-radius of the arc
- * @param angle x-axis-rotation of the arc
- * @param LAF large-arc-flag of the arc
- * @param SF sweep-flag of the arc
- * @param X2 the ending x position
- * @param Y2 the ending y position
- * @param distance the point distance
- * @returns the segment length, point, min & max
- */
-const segmentArcFactory = (
-  X1: number,
-  Y1: number,
-  RX: number,
-  RY: number,
-  angle: number,
-  LAF: number,
-  SF: number,
-  X2: number,
-  Y2: number,
-  distance: number,
-): LengthFactory => {
-  const distanceIsNumber = typeof distance === 'number';
-  let x = X1;
-  let y = Y1;
-  let LENGTH = 0;
-  let prev = [x, y, LENGTH];
-  let cur = [x, y] as [number, number];
-  let t = 0;
-  let POINT = { x: 0, y: 0 };
-  let POINTS = [{ x, y }];
-
-  if (distanceIsNumber && distance <= 0) {
-    POINT = { x, y };
-  }
-
-  const sampleSize = 300;
-  for (let j = 0; j <= sampleSize; j += 1) {
-    t = j / sampleSize;
-
-    ({ x, y } = getPointAtArcSegmentLength(X1, Y1, RX, RY, angle, LAF, SF, X2, Y2, t));
-    POINTS = [...POINTS, { x, y }];
-    LENGTH += distanceSquareRoot(cur, [x, y]);
-    cur = [x, y];
-
-    if (distanceIsNumber && LENGTH > distance && distance > prev[2]) {
-      const dv = (LENGTH - distance) / (LENGTH - prev[2]);
-
-      POINT = {
-        x: cur[0] * (1 - dv) + prev[0] * dv,
-        y: cur[1] * (1 - dv) + prev[1] * dv,
-      };
-    }
-    prev = [x, y, LENGTH];
-  }
-
-  if (distanceIsNumber && distance >= LENGTH) {
-    POINT = { x: X2, y: Y2 };
-  }
-
-  return {
-    length: LENGTH,
-    point: POINT,
-    min: {
-      x: Math.min(...POINTS.map(n => n.x)),
-      y: Math.min(...POINTS.map(n => n.y)),
-    },
-    max: {
-      x: Math.max(...POINTS.map(n => n.x)),
-      y: Math.max(...POINTS.map(n => n.y)),
-    },
-  };
-};
-export default segmentArcFactory;

package/src/util/segmentCubicFactory.ts

@@ -1,114 +0,0 @@
-import { LengthFactory } from 'src/interface';
-import distanceSquareRoot from '../math/distanceSquareRoot';
-
-/**
- * Returns a {x,y} point at a given length, the total length and
- * the minimum and maximum {x,y} coordinates of a C (cubic-bezier) 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: number,
-  y1: number,
-  c1x: number,
-  c1y: number,
-  c2x: number,
-  c2y: number,
-  x2: number,
-  y2: number,
-  t: number,
-): { x: number; y: 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 C (cubic-bezier) segment
- * or an {x,y} point at a given length.
- *
- * @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 point distance
- * @returns the segment length, point, min & max
- */
-const segmentCubicFactory = (
-  x1: number,
-  y1: number,
-  c1x: number,
-  c1y: number,
-  c2x: number,
-  c2y: number,
-  x2: number,
-  y2: number,
-  distance?: number,
-): LengthFactory => {
-  const distanceIsNumber = typeof distance === 'number';
-  let x = x1;
-  let y = y1;
-  let LENGTH = 0;
-  let prev = [x, y, LENGTH];
-  let cur = [x, y] as [number, number];
-  let t = 0;
-  let POINT = { x: 0, y: 0 };
-  let POINTS = [{ x, y }];
-
-  if (distanceIsNumber && distance <= 0) {
-    POINT = { x, y };
-  }
-
-  const sampleSize = 300;
-  for (let j = 0; j <= sampleSize; j += 1) {
-    t = j / sampleSize;
-
-    ({ x, y } = getPointAtCubicSegmentLength(x1, y1, c1x, c1y, c2x, c2y, x2, y2, t));
-    POINTS = [...POINTS, { x, y }];
-    LENGTH += distanceSquareRoot(cur, [x, y]);
-    cur = [x, y];
-
-    if (distanceIsNumber && LENGTH > distance && distance > prev[2]) {
-      const dv = (LENGTH - distance) / (LENGTH - prev[2]);
-
-      POINT = {
-        x: cur[0] * (1 - dv) + prev[0] * dv,
-        y: cur[1] * (1 - dv) + prev[1] * dv,
-      };
-    }
-    prev = [x, y, LENGTH];
-  }
-
-  if (distanceIsNumber && distance >= LENGTH) {
-    POINT = { x: x2, y: y2 };
-  }
-
-  return {
-    length: LENGTH,
-    point: POINT,
-    min: {
-      x: Math.min(...POINTS.map(n => n.x)),
-      y: Math.min(...POINTS.map(n => n.y)),
-    },
-    max: {
-      x: Math.max(...POINTS.map(n => n.x)),
-      y: Math.max(...POINTS.map(n => n.y)),
-    },
-  };
-};
-export default segmentCubicFactory;

package/src/util/segmentLineFactory.ts

@@ -1,45 +0,0 @@
-import midPoint from '../math/midPoint';
-import distanceSquareRoot from '../math/distanceSquareRoot';
-import type { LengthFactory } from '../interface';
-
-/**
- * Returns a {x,y} point at a given length, the total length and
- * the minimum and maximum {x,y} coordinates of a line (L,V,H,Z) segment.
- *
- * @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
- * @returns the segment length, point, min & max
- */
-const segmentLineFactory = (x1: number, y1: number, x2: number, y2: number, distance?: number): LengthFactory => {
-  const length = distanceSquareRoot([x1, y1], [x2, y2]);
-  let point = { x: 0, y: 0 };
-
-  /* istanbul ignore else */
-  if (typeof distance === 'number') {
-    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 {
-    length,
-    point,
-    min: {
-      x: Math.min(x1, x2),
-      y: Math.min(y1, y2),
-    },
-    max: {
-      x: Math.max(x1, x2),
-      y: Math.max(y1, y2),
-    },
-  };
-};
-export default segmentLineFactory;

package/src/util/segmentQuadFactory.ts

@@ -1,109 +0,0 @@
-import { LengthFactory } from 'src/interface';
-import distanceSquareRoot from '../math/distanceSquareRoot';
-
-/**
- * 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: number,
-  y1: number,
-  cx: number,
-  cy: number,
-  x2: number,
-  y2: number,
-  t: number,
-): { x: number; y: 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 a {x,y} point at a given length, the total length and
- * the minimum and maximum {x,y} coordinates of a Q (quadratic-bezier) segment.
- *
- * @param x1 the starting point X
- * @param y1 the starting point Y
- * @param qx the control point X
- * @param qy the control point Y
- * @param x2 the ending point X
- * @param y2 the ending point Y
- * @param distance the distance to point
- * @returns the segment length, point, min & max
- */
-const segmentQuadFactory = (
-  x1: number,
-  y1: number,
-  qx: number,
-  qy: number,
-  x2: number,
-  y2: number,
-  distance?: number,
-): LengthFactory => {
-  const distanceIsNumber = typeof distance === 'number';
-  let x = x1;
-  let y = y1;
-  let LENGTH = 0;
-  let prev = [x, y, LENGTH];
-  let cur = [x, y] as [number, number];
-  let t = 0;
-  let POINT = { x: 0, y: 0 };
-  let POINTS = [{ x, y }];
-
-  if (distanceIsNumber && distance <= 0) {
-    POINT = { x, y };
-  }
-
-  const sampleSize = 300;
-  for (let j = 0; j <= sampleSize; j += 1) {
-    t = j / sampleSize;
-
-    ({ x, y } = getPointAtQuadSegmentLength(x1, y1, qx, qy, x2, y2, t));
-    POINTS = [...POINTS, { x, y }];
-    LENGTH += distanceSquareRoot(cur, [x, y]);
-    cur = [x, y];
-
-    if (distanceIsNumber && LENGTH > distance && distance > prev[2]) {
-      const dv = (LENGTH - distance) / (LENGTH - prev[2]);
-
-      POINT = {
-        x: cur[0] * (1 - dv) + prev[0] * dv,
-        y: cur[1] * (1 - dv) + prev[1] * dv,
-      };
-    }
-    prev = [x, y, LENGTH];
-  }
-
-  /* istanbul ignore else */
-  if (distanceIsNumber && distance >= LENGTH) {
-    POINT = { x: x2, y: y2 };
-  }
-
-  return {
-    length: LENGTH,
-    point: POINT,
-    min: {
-      x: Math.min(...POINTS.map(n => n.x)),
-      y: Math.min(...POINTS.map(n => n.y)),
-    },
-    max: {
-      x: Math.max(...POINTS.map(n => n.x)),
-      y: Math.max(...POINTS.map(n => n.y)),
-    },
-  };
-};
-export default segmentQuadFactory;