svg-path-commander 2.1.2 → 2.1.5

package/src/process/optimizePath.ts

@@ -1,63 +0,0 @@
-import pathToAbsolute from '../convert/pathToAbsolute';
-import shortenSegment from './shortenSegment';
-import paramsParser from '../parser/paramsParser';
-import type { AbsoluteSegment, PathArray, PathCommand } from '../types';
-import iterate from './iterate';
-import normalizeSegment from './normalizeSegment';
-import relativizeSegment from './relativizeSegment';
-import roundSegment from './roundSegment';
-
-/**
- * Optimizes a `pathArray` object:
- * * convert segments to shorthand if possible
- * * select shortest segments from absolute and relative `pathArray`s
- *
- * @param pathInput a string or `pathArray`
- * @param roundOption the amount of decimals to round values to
- * @returns the optimized `pathArray`
- */
-const optimizePath = (pathInput: PathArray, roundOption: number) => {
-  const path = pathToAbsolute(pathInput);
-  // allow for ZERO decimals or use an aggressive value of 2
-  const round =
-    typeof roundOption === 'number' && roundOption >= 0 ? roundOption : /* istanbul ignore next @preserve */ 2;
-  // this utility overrides the iterator params
-  const optimParams = { ...paramsParser };
-
-  const allPathCommands = [] as PathCommand[];
-  let pathCommand = 'M' as PathCommand;
-  let prevCommand = 'Z' as PathCommand;
-
-  return iterate(path, (seg, i, lastX, lastY) => {
-    optimParams.x = lastX;
-    optimParams.y = lastY;
-    // const absoluteSegment = absolutizeSegment(seg, optimParams);
-    const normalizedSegment = normalizeSegment(seg, optimParams);
-    let result = seg;
-    [pathCommand] = seg;
-
-    // Save current path command
-    allPathCommands[i] = pathCommand;
-    if (i) {
-      // Get previous path command for `shortenSegment`
-      prevCommand = allPathCommands[i - 1];
-      const shortSegment = shortenSegment(seg as AbsoluteSegment, normalizedSegment, optimParams, prevCommand);
-      const absSegment = roundSegment(shortSegment, round);
-      const absString = absSegment.join('');
-      const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);
-      const relSegment = roundSegment(relativeSegment, round);
-      const relString = relSegment.join('');
-      result = absString.length < relString.length ? absSegment : relSegment;
-    }
-
-    const seglen = normalizedSegment.length;
-    optimParams.x1 = +normalizedSegment[seglen - 2];
-    optimParams.y1 = +normalizedSegment[seglen - 1];
-    optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;
-    optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;
-
-    return result;
-  });
-};
-
-export default optimizePath;

package/src/process/projection2d.ts

@@ -1,52 +0,0 @@
-import CSSMatrix from '@thednp/dommatrix';
-import { type PointTuple } from '../types';
-
-/**
- * Transforms a specified point using a matrix, returning a new
- * Tuple *Object* comprising of the transformed point.
- * Neither the matrix nor the original point are altered.
- *
- * @copyright thednp © 2021
- *
- * @param cssm CSSMatrix instance
- * @param v Tuple
- * @return the resulting Tuple
- */
-const translatePoint = (cssm: CSSMatrix, v: [number, number, number, number]): [number, number, number, number] => {
-  let m = CSSMatrix.Translate(v[0], v[1], v[2]);
-
-  [, , , m.m44] = v;
-  m = cssm.multiply(m);
-
-  return [m.m41, m.m42, m.m43, m.m44];
-};
-
-/**
- * Returns the [x,y] projected coordinates for a given an [x,y] point
- * and an [x,y,z] perspective origin point.
- *
- * Equation found here =>
- * http://en.wikipedia.org/wiki/3D_projection#Diagram
- * Details =>
- * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel
- *
- * @param m the transformation matrix
- * @param point2D the initial [x,y] coordinates
- * @param origin the [x,y,z] transform origin
- * @returns the projected [x,y] coordinates
- */
-const projection2d = (m: CSSMatrix, point2D: PointTuple, origin: [number, number, number]): PointTuple => {
-  const [originX, originY, originZ] = origin;
-  const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);
-
-  const relativePositionX = x - originX;
-  const relativePositionY = y - originY;
-  const relativePositionZ = z - originZ;
-
-  return [
-    // protect against division by ZERO
-    relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) + originX,
-    relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) + originY,
-  ];
-};
-export default projection2d;

package/src/process/quadToCubic.ts

@@ -1,31 +0,0 @@
-/**
- * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).
- *
- * @param x1 curve start x
- * @param y1 curve start y
- * @param qx control point x
- * @param qy control point y
- * @param x2 curve end x
- * @param y2 curve end y
- * @returns the cubic-bezier segment
- */
-const quadToCubic = (
-  x1: number,
-  y1: number,
-  qx: number,
-  qy: number,
-  x2: number,
-  y2: number,
-): [number, number, number, number, number, number] => {
-  const r13 = 1 / 3;
-  const r23 = 2 / 3;
-  return [
-    r13 * x1 + r23 * qx, // cpx1
-    r13 * y1 + r23 * qy, // cpy1
-    r13 * x2 + r23 * qx, // cpx2
-    r13 * y2 + r23 * qy, // cpy2
-    x2,
-    y2, // x,y
-  ];
-};
-export default quadToCubic;

package/src/process/relativizeSegment.ts

@@ -1,59 +0,0 @@
-import type {
-  RelativeSegment,
-  RelativeCommand,
-  PathSegment,
-  aSegment,
-  vSegment,
-  hSegment,
-  qSegment,
-  tSegment,
-  sSegment,
-  cSegment,
-  MSegment,
-  lSegment,
-} from '../types';
-
-/**
- * Returns a relative segment of a `PathArray` object.
- *
- * @param segment the segment object
- * @param index the segment index
- * @param lastX the last known X value
- * @param lastY the last known Y value
- * @returns the relative segment
- */
-const relativizeSegment = (segment: PathSegment, index: number, lastX: number, lastY: number) => {
-  const [pathCommand] = segment;
-  const relCommand = pathCommand.toLowerCase() as RelativeCommand;
-  const isRelative = pathCommand === relCommand;
-
-  /* istanbul ignore else @preserve */
-  if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;
-
-  if (relCommand === 'a') {
-    return [
-      relCommand,
-      segment[1],
-      segment[2],
-      segment[3],
-      segment[4],
-      segment[5],
-      (segment as aSegment)[6] - lastX,
-      (segment as aSegment)[7] - lastY,
-    ] as aSegment;
-  } else if (relCommand === 'v') {
-    return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;
-  } else if (relCommand === 'h') {
-    return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;
-  } else if (relCommand === 'l') {
-    return [relCommand, (segment as lSegment)[1] - lastX, (segment as lSegment)[2] - lastY] as lSegment;
-  } else {
-    // use brakets for `eslint: no-case-declaration`
-    // https://stackoverflow.com/a/50753272/803358
-    const relValues = (segment.slice(1) as number[]).map((n, j) => n - (j % 2 ? lastY : lastX));
-    // for c, s, q, t
-    return [relCommand as RelativeCommand | number].concat(relValues) as qSegment | tSegment | sSegment | cSegment;
-  }
-};
-
-export default relativizeSegment;

package/src/process/reverseCurve.ts

@@ -1,24 +0,0 @@
-import type { CSegment, CurveArray, MSegment, PathCommand } from '../types';
-
-/**
- * Reverses all segments of a `pathArray`
- * which consists of only C (cubic-bezier) path commands.
- *
- * @param path the source `pathArray`
- * @returns the reversed `pathArray`
- */
-const reverseCurve = (path: CurveArray) => {
-  const rotatedCurve = path
-    .slice(1)
-    .map((x, i, curveOnly) =>
-      !i ? path[0].slice(1).concat(x.slice(1) as number[]) : curveOnly[i - 1].slice(-2).concat(x.slice(1)),
-    )
-    .map(x => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))
-    .reverse() as (MSegment | CSegment)[];
-
-  return [['M' as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))].concat(
-    rotatedCurve.map(x => ['C' as PathCommand | number].concat(x.slice(2))),
-  ) as CurveArray;
-};
-
-export default reverseCurve;

package/src/process/reversePath.ts

@@ -1,114 +0,0 @@
-import type {
-  ASegment,
-  CSegment,
-  HSegment,
-  MSegment,
-  PathArray,
-  PathSegment,
-  PointTuple,
-  QSegment,
-  SSegment,
-  TSegment,
-  VSegment,
-} from '../types';
-import pathToAbsolute from '../convert/pathToAbsolute';
-import normalizePath from './normalizePath';
-import iterate from './iterate';
-
-/**
- * Reverses all segments of a `pathArray` and returns a new `pathArray` instance
- * with absolute values.
- *
- * @param pathInput the source `pathArray`
- * @returns the reversed `pathArray`
- */
-const reversePath = (pathInput: PathArray) => {
-  const absolutePath = pathToAbsolute(pathInput);
-  const normalizedPath = normalizePath(absolutePath);
-  const pLen = absolutePath.length;
-  const isClosed = absolutePath[pLen - 1][0] === 'Z';
-
-  const reversedPath = iterate(absolutePath, (segment, i) => {
-    const normalizedSegment = normalizedPath[i];
-    const prevSeg = i && absolutePath[i - 1];
-    const prevCommand = prevSeg && prevSeg[0];
-    const nextSeg = absolutePath[i + 1];
-    const nextCommand = nextSeg && nextSeg[0];
-    const [pathCommand] = segment;
-    const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;
-    let result = segment;
-
-    switch (pathCommand) {
-      case 'M':
-        result = (isClosed ? ['Z'] : [pathCommand, x, y]) as PathSegment;
-        break;
-      case 'A':
-        result = [
-          pathCommand,
-          segment[1],
-          segment[2],
-          segment[3],
-          segment[4],
-          segment[5] === 1 ? 0 : 1,
-          x,
-          y,
-        ] as ASegment;
-        break;
-      case 'C':
-        if (nextSeg && nextCommand === 'S') {
-          result = ['S', segment[1], segment[2], x, y] as SSegment;
-        } else {
-          result = [pathCommand, segment[3], segment[4], segment[1], segment[2], x, y] as CSegment;
-        }
-        break;
-      case 'S':
-        if (prevCommand && 'CS'.includes(prevCommand) && (!nextSeg || nextCommand !== 'S')) {
-          result = [
-            'C',
-            normalizedSegment[3],
-            normalizedSegment[4],
-            normalizedSegment[1],
-            normalizedSegment[2],
-            x,
-            y,
-          ] as CSegment;
-        } else {
-          result = [pathCommand, normalizedSegment[1], normalizedSegment[2], x, y] as SSegment;
-        }
-        break;
-      case 'Q':
-        if (nextSeg && nextCommand === 'T') {
-          result = ['T', x, y] as TSegment;
-        } else {
-          result = [pathCommand, segment[1], segment[2], x, y] as QSegment;
-        }
-        break;
-      case 'T':
-        if (prevCommand && 'QT'.includes(prevCommand) && (!nextSeg || nextCommand !== 'T')) {
-          result = ['Q', normalizedSegment[1], normalizedSegment[2], x, y] as QSegment;
-        } else {
-          result = [pathCommand, x, y] as TSegment;
-        }
-        break;
-      case 'Z':
-        result = ['M', x, y] as MSegment;
-        break;
-      case 'H':
-        result = [pathCommand, x] as HSegment;
-        break;
-      case 'V':
-        result = [pathCommand, y] as VSegment;
-        break;
-      default:
-        result = [pathCommand as typeof pathCommand | number].concat(segment.slice(1, -2), x, y) as PathSegment;
-    }
-
-    return result;
-  });
-
-  return (
-    isClosed ? reversedPath.reverse() : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())
-  ) as PathArray;
-};
-
-export default reversePath;

package/src/process/roundPath.ts

@@ -1,33 +0,0 @@
-import type { PathArray } from '../types';
-import defaultOptions from '../options/options';
-import iterate from './iterate';
-import roundSegment from './roundSegment';
-
-/**
- * Rounds the values of a `pathArray` instance to
- * a specified amount of decimals and returns it.
- *
- * @param path the source `pathArray`
- * @param roundOption the amount of decimals to round numbers to
- * @returns the resulted `pathArray` with rounded values
- */
-const roundPath = (path: PathArray, roundOption?: number | 'off') => {
-  let { round } = defaultOptions;
-  // allow for ZERO decimals
-  round =
-    roundOption === 'off'
-      ? roundOption
-      : typeof roundOption === 'number' && roundOption >= 0
-      ? roundOption
-      : typeof round === 'number' && round >= 0
-      ? round
-      : /* istanbul ignore next @preserve */ 'off';
-
-  /* istanbul ignore else @preserve */
-  if (round === 'off') return path.slice(0) as PathArray;
-
-  return iterate<typeof path>(path, segment => {
-    return roundSegment(segment, round);
-  });
-};
-export default roundPath;

package/src/process/roundSegment.ts

@@ -1,9 +0,0 @@
-import type { PathCommand, PathSegment } from '../types';
-import roundTo from '../math/roundTo';
-
-const roundSegment = <T extends PathSegment>(segment: T, roundOption: number) => {
-  const values = (segment.slice(1) as number[]).map(n => roundTo(n, roundOption));
-  return [segment[0] as PathCommand | number].concat(values) as T;
-};
-
-export default roundSegment;

package/src/process/segmentToCubic.ts

@@ -1,48 +0,0 @@
-import arcToCubic from './arcToCubic';
-import quadToCubic from './quadToCubic';
-import lineToCubic from './lineToCubic';
-import type { CSegment, MSegment, PathSegment } from '../types';
-import type { ParserParams } from '../interface';
-
-/**
- * Converts any segment to C (cubic-bezier).
- *
- * @param segment the source segment
- * @param params the source segment parameters
- * @returns the cubic-bezier segment
- */
-const segmentToCubic = (segment: PathSegment, params: ParserParams) => {
-  const [pathCommand] = segment;
-  const values = segment.slice(1).map(Number);
-  const [x, y] = values;
-  // let args;
-  const { x1: px1, y1: py1, x: px, y: py } = params;
-
-  if (!'TQ'.includes(pathCommand)) {
-    params.qx = null;
-    params.qy = null;
-  }
-
-  if (pathCommand === 'M') {
-    params.x = x;
-    params.y = y;
-    return segment;
-  } else if (pathCommand === 'A') {
-    return ['C' as string | number].concat(
-      arcToCubic(px1, py1, values[0], values[1], values[2], values[3], values[4], values[5], values[6]),
-    ) as CSegment;
-  } else if (pathCommand === 'Q') {
-    params.qx = x;
-    params.qy = y;
-    return ['C' as string | number].concat(
-      quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),
-    ) as CSegment;
-  } else if (pathCommand === 'L') {
-    return ['C' as string | number].concat(lineToCubic(px1, py1, x, y)) as CSegment;
-  } else if (pathCommand === 'Z') {
-    return ['C' as string | number].concat(lineToCubic(px1, py1, px, py)) as CSegment;
-  }
-
-  return segment as MSegment | CSegment;
-};
-export default segmentToCubic;

package/src/process/shortenSegment.ts

@@ -1,71 +0,0 @@
-import defaultOptions from '../options/options';
-import type { ParserParams } from '../interface';
-import roundTo from '../math/roundTo';
-import type { AbsoluteSegment, NormalSegment, PathCommand, ShortSegment, SSegment, TSegment } from '../types';
-
-/**
- * Shorten a single segment of a `pathArray` object.
- *
- * @param segment the `absoluteSegment` object
- * @param normalSegment the `normalSegment` object
- * @param params the coordinates of the previous segment
- * @param prevCommand the path command of the previous segment
- * @returns the shortened segment
- */
-const shortenSegment = (
-  segment: AbsoluteSegment,
-  normalSegment: NormalSegment,
-  params: ParserParams,
-  prevCommand: PathCommand,
-): ShortSegment => {
-  const [pathCommand] = segment;
-  const { round: defaultRound } = defaultOptions;
-  const round = typeof defaultRound === 'number' ? defaultRound : /* istanbul ignore next */ 4;
-  const normalValues = normalSegment.slice(1) as number[];
-  const { x1, y1, x2, y2, x, y } = params;
-  const [nx, ny] = normalValues.slice(-2);
-  const result = segment;
-
-  if (!'TQ'.includes(pathCommand)) {
-    // optional but good to be cautious
-    params.qx = null;
-    params.qy = null;
-  }
-
-  if (pathCommand === 'L') {
-    if (roundTo(x, round) === roundTo(nx, round)) {
-      return ['V', ny];
-    } else if (roundTo(y, round) === roundTo(ny, round)) {
-      return ['H', nx];
-    }
-  } else if (pathCommand === 'C') {
-    const [nx1, ny1] = normalValues;
-    params.x1 = nx1;
-    params.y1 = ny1;
-
-    if (
-      'CS'.includes(prevCommand) &&
-      ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) && roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||
-        (roundTo(x1, round) === roundTo(x2 * 2 - x, round) && roundTo(y1, round) === roundTo(y2 * 2 - y, round)))
-    ) {
-      return ['S', normalValues[2], normalValues[3], normalValues[4], normalValues[5]] as SSegment;
-    }
-  } else if (pathCommand === 'Q') {
-    const [qx, qy] = normalValues;
-    params.qx = qx;
-    params.qy = qy;
-
-    if (
-      'QT'.includes(prevCommand) &&
-      roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&
-      roundTo(qy, round) === roundTo(y1 * 2 - y2, round)
-    ) {
-      return ['T', normalValues[2], normalValues[3]] as TSegment;
-    }
-  }
-
-  // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)
-  return result as ShortSegment;
-};
-
-export default shortenSegment;

package/src/process/splitCubic.ts

@@ -1,29 +0,0 @@
-import midPoint from '../math/midPoint';
-import type { CubicSegment, PointTuple } from '../types';
-
-/**
- * Split a cubic-bezier segment into two.
- *
- * @param pts the cubic-bezier parameters
- * @param ratio the cubic-bezier parameters
- * @return two new cubic-bezier segments
- */
-const splitCubic = (pts: number[], ratio = 0.5): [CubicSegment, CubicSegment] => {
-  const t = ratio;
-  const p0 = pts.slice(0, 2) as PointTuple;
-  const p1 = pts.slice(2, 4) as PointTuple;
-  const p2 = pts.slice(4, 6) as PointTuple;
-  const p3 = pts.slice(6, 8) as PointTuple;
-  const p4 = midPoint(p0, p1, t);
-  const p5 = midPoint(p1, p2, t);
-  const p6 = midPoint(p2, p3, t);
-  const p7 = midPoint(p4, p5, t);
-  const p8 = midPoint(p5, p6, t);
-  const p9 = midPoint(p7, p8, t);
-
-  return [
-    ['C', p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],
-    ['C', p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],
-  ];
-};
-export default splitCubic;

package/src/process/splitPath.ts

@@ -1,63 +0,0 @@
-import paramsParser from '../parser/paramsParser';
-import type { AbsoluteCommand, HSegment, MSegment, PathArray, PointTuple, RelativeCommand, VSegment } from '../types';
-
-/**
- * Split a path into an `Array` of sub-path strings.
- *
- * In the process, values are converted to absolute
- * for visual consistency.
- *
- * @param pathInput the source `pathArray`
- * @return an array with all sub-path strings
- */
-const splitPath = (pathInput: PathArray): PathArray[] => {
-  const composite = [] as PathArray[];
-  let path: PathArray;
-  let pi = -1;
-  let x = 0;
-  let y = 0;
-  let mx = 0;
-  let my = 0;
-  const params = { ...paramsParser };
-
-  pathInput.forEach(seg => {
-    const [pathCommand] = seg;
-    const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;
-    const relCommand = pathCommand.toLowerCase() as RelativeCommand;
-    const isRelative = pathCommand === relCommand;
-    const values = seg.slice(1) as number[];
-
-    if (absCommand === 'M') {
-      pi += 1;
-      [x, y] = values as PointTuple;
-      x += isRelative ? params.x : 0;
-      y += isRelative ? params.y : 0;
-      mx = x;
-      my = y;
-      path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];
-    } else {
-      if (absCommand === 'Z') {
-        x = mx;
-        y = my;
-      } else if (absCommand === 'H') {
-        [, x] = seg as HSegment;
-        x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;
-      } else if (absCommand === 'V') {
-        [, y] = seg as VSegment;
-        y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;
-      } else {
-        [x, y] = seg.slice(-2) as PointTuple;
-        x += isRelative ? params.x : 0;
-        y += isRelative ? params.y : 0;
-      }
-      path.push(seg);
-    }
-
-    params.x = x;
-    params.y = y;
-    composite[pi] = path;
-  });
-
-  return composite;
-};
-export default splitPath;