svg-path-commander 2.1.3 → 2.1.6

package/src/util/getPointAtLength.ts

@@ -1,110 +0,0 @@
-import DISTANCE_EPSILON from './distanceEpsilon';
-import type { MSegment, PathArray, PointTuple } from '../types';
-import iterate from '../process/iterate';
-import { getLineLength, getPointAtLineLength } from '../math/lineTools';
-import { getArcLength, getPointAtArcLength } from '../math/arcTools';
-import { getCubicLength, getPointAtCubicLength } from '../math/cubicTools';
-import { getQuadLength, getPointAtQuadLength } from '../math/quadTools';
-import normalizePath from '../process/normalizePath';
-
-/**
- * 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) => {
-  const path = normalizePath(pathInput);
-  let isM = false;
-  let data = [] as number[];
-  let pathCommand = 'M';
-  let x = 0;
-  let y = 0;
-  let [mx, my] = path[0].slice(1) as PointTuple;
-  const distanceIsNumber = typeof distance === 'number';
-  let point = { x: mx, y: my };
-  let length = 0;
-  let POINT = point;
-  let totalLength = 0;
-
-  if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;
-
-  // for (let i = 0; i < pathLen; i += 1) {
-  iterate(path, (seg, _, lastX, lastY) => {
-    [pathCommand] = seg;
-    isM = pathCommand === 'M';
-    data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;
-
-    // this segment is always ZERO
-    /* istanbul ignore else @preserve */
-    if (isM) {
-      // remember mx, my for Z
-      [, mx, my] = seg as MSegment;
-      point = { x: mx, y: my };
-      length = 0;
-    } else if (pathCommand === 'L') {
-      point = getPointAtLineLength(data[0], data[1], data[2], data[3], distance - totalLength);
-      length = getLineLength(data[0], data[1], data[2], data[3]);
-    } else if (pathCommand === 'A') {
-      point = getPointAtArcLength(
-        data[0],
-        data[1],
-        data[2],
-        data[3],
-        data[4],
-        data[5],
-        data[6],
-        data[7],
-        data[8],
-        distance - totalLength,
-      );
-      length = getArcLength(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]);
-    } else if (pathCommand === 'C') {
-      point = getPointAtCubicLength(
-        data[0],
-        data[1],
-        data[2],
-        data[3],
-        data[4],
-        data[5],
-        data[6],
-        data[7],
-        distance - totalLength,
-      );
-      length = getCubicLength(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
-    } else if (pathCommand === 'Q') {
-      point = getPointAtQuadLength(data[0], data[1], data[2], data[3], data[4], data[5], distance - totalLength);
-      length = getQuadLength(data[0], data[1], data[2], data[3], data[4], data[5]);
-    } else if (pathCommand === 'Z') {
-      data = [lastX, lastY, mx, my];
-      point = { x: mx, y: my };
-
-      length = getLineLength(data[0], data[1], data[2], data[3]);
-    }
-
-    [x, y] = data.slice(-2);
-
-    if (totalLength < distance) {
-      POINT = point;
-    } else {
-      // totalLength >= distance
-      // stop right here
-      // stop iterator now!
-      return false;
-    }
-
-    totalLength += length;
-    return;
-  });
-
-  // native `getPointAtLength` behavior when the given distance
-  // is higher than total length
-  if (distance > totalLength - DISTANCE_EPSILON) {
-    return { x, y };
-  }
-
-  return POINT;
-};
-
-export default getPointAtLength;

package/src/util/getPropertiesAtLength.ts

@@ -1,67 +0,0 @@
-import type { PathArray, PathSegment } from '../types';
-import type { SegmentProperties } from '../interface';
-import parsePathString from '../parser/parsePathString';
-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 pathInput target `pathArray`
- * @param distance the given length
- * @returns the requested properties
- */
-const getPropertiesAtLength = (pathInput: string | PathArray, distance?: number): SegmentProperties => {
-  const pathArray = parsePathString(pathInput);
-
-  let pathTemp = pathArray.slice(0) as PathArray;
-  let pathLength = getTotalLength(pathTemp);
-  let index = pathTemp.length - 1;
-  let lengthAtSegment = 0;
-  let length = 0;
-  let segment = pathArray[0] as PathSegment;
-
-  // If the path is empty, return 0.
-  if (index <= 0 || !distance || !Number.isFinite(distance)) {
-    return {
-      segment,
-      index: 0,
-      length,
-      lengthAtSegment,
-    };
-  }
-
-  if (distance >= pathLength) {
-    pathTemp = pathArray.slice(0, -1) as PathArray;
-    lengthAtSegment = getTotalLength(pathTemp);
-    length = pathLength - lengthAtSegment;
-    segment = pathArray[index];
-    return {
-      segment,
-      index,
-      length,
-      lengthAtSegment,
-    };
-  }
-
-  const segments = [] as SegmentProperties[];
-  while (index > 0) {
-    segment = pathTemp[index];
-    pathTemp = pathTemp.slice(0, -1) as PathArray;
-    lengthAtSegment = getTotalLength(pathTemp);
-    length = pathLength - lengthAtSegment;
-    pathLength = lengthAtSegment;
-
-    segments.push({
-      segment,
-      index,
-      length,
-      lengthAtSegment,
-    });
-    index -= 1;
-  }
-
-  return segments.find(({ lengthAtSegment: l }) => l <= distance) as SegmentProperties;
-};
-
-export default getPropertiesAtLength;

package/src/util/getPropertiesAtPoint.ts

@@ -1,84 +0,0 @@
-import type { PathArray, Point } from '../types';
-import type { PointProperties } from '../interface';
-import getPointAtLength from './getPointAtLength';
-import getPropertiesAtLength from './getPropertiesAtLength';
-import getTotalLength from './getTotalLength';
-import parsePathString from '../parser/parsePathString';
-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 pathInput target `pathArray`
- * @param point the given point
- * @returns the requested properties
- */
-const getPropertiesAtPoint = (pathInput: string | PathArray, point: Point): PointProperties => {
-  const path = parsePathString(pathInput);
-  const normalPath = normalizePath(path);
-  const pathLength = getTotalLength(normalPath);
-  const distanceTo = (p: Point) => {
-    const dx = p.x - point.x;
-    const dy = p.y - point.y;
-    return dx * dx + dy * dy;
-  };
-  let precision = 8;
-  let scan: Point;
-  let closest = { x: 0, y: 0 }; // make TS happy
-  let scanDistance = 0;
-  let bestLength = 0;
-  let bestDistance = Infinity;
-
-  // linear scan for coarse approximation
-  for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {
-    scan = getPointAtLength(normalPath, scanLength);
-    scanDistance = distanceTo(scan);
-
-    if (scanDistance < bestDistance) {
-      closest = scan;
-      bestLength = scanLength;
-      bestDistance = scanDistance;
-    }
-  }
-
-  // binary search for precise estimate
-  precision /= 2;
-  let before: { x: number; y: number };
-  let after: { x: number; y: number };
-  let beforeLength = 0;
-  let afterLength = 0;
-  let beforeDistance = 0;
-  let afterDistance = 0;
-
-  while (precision > 0.000001) {
-    beforeLength = bestLength - precision;
-    before = getPointAtLength(normalPath, beforeLength);
-    beforeDistance = distanceTo(before);
-    afterLength = bestLength + precision;
-    after = getPointAtLength(normalPath, afterLength);
-    afterDistance = distanceTo(after);
-
-    if (beforeLength >= 0 && beforeDistance < bestDistance) {
-      closest = before;
-      bestLength = beforeLength;
-      bestDistance = beforeDistance;
-    } else if (afterLength <= pathLength && afterDistance < bestDistance) {
-      closest = after;
-      bestLength = afterLength;
-      bestDistance = afterDistance;
-    } else {
-      precision /= 2;
-    }
-    if (precision < 0.00001) break;
-  }
-
-  const segment = getPropertiesAtLength(path, bestLength);
-  const distance = Math.sqrt(bestDistance);
-
-  return { closest, distance, segment };
-};
-
-export default getPropertiesAtPoint;

package/src/util/getSegmentAtLength.ts

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

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

@@ -1,133 +0,0 @@
-import type { LSegment, MSegment, PathArray, PointTuple } from '../types';
-import { getLineLength } from '../math/lineTools';
-import { getArcLength } from '../math/arcTools';
-import { getCubicLength } from '../math/cubicTools';
-import { getQuadLength } from '../math/quadTools';
-import iterate from '../process/iterate';
-import parsePathString from '../parser/parsePathString';
-import absolutizeSegment from '../process/absolutizeSegment';
-
-/**
- * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.
- *
- *
- * @param pathInput the target `pathArray`
- * @returns the shape total length
- */
-const getTotalLength = (pathInput: string | PathArray) => {
-  const path = parsePathString(pathInput);
-  let paramX1 = 0;
-  let paramY1 = 0;
-  let paramX2 = 0;
-  let paramY2 = 0;
-  let paramQX = 0;
-  let paramQY = 0;
-  let pathCommand = 'M';
-  let mx = 0;
-  let my = 0;
-  let totalLength = 0;
-
-  iterate(path, (seg, index, lastX, lastY) => {
-    [pathCommand] = seg;
-    const absCommand = pathCommand.toUpperCase();
-    const isRelative = absCommand !== pathCommand;
-    const absoluteSegment = isRelative ? absolutizeSegment(seg, index, lastX, lastY) : (seg.slice(0) as typeof seg);
-
-    const normalSegment =
-      absCommand === 'V'
-        ? (['L', lastX, absoluteSegment[1]] as LSegment)
-        : absCommand === 'H'
-        ? (['L', absoluteSegment[1], lastY] as LSegment)
-        : absoluteSegment;
-    [pathCommand] = normalSegment;
-
-    if (!'TQ'.includes(absCommand)) {
-      // optional but good to be cautious
-      paramQX = 0;
-      paramQY = 0;
-    }
-
-    // this segment is always ZERO
-    /* istanbul ignore else @preserve */
-    if (pathCommand === 'M') {
-      // remember mx, my for Z
-      [, mx, my] = normalSegment as MSegment;
-    } else if (pathCommand === 'L') {
-      totalLength += getLineLength(lastX, lastY, normalSegment[1] as number, normalSegment[2] as number);
-    } else if (pathCommand === 'A') {
-      totalLength += getArcLength(
-        lastX,
-        lastY,
-        normalSegment[1] as number,
-        normalSegment[2] as number,
-        normalSegment[3] as number,
-        normalSegment[4] as number,
-        normalSegment[5] as number,
-        normalSegment[6] as number,
-        normalSegment[7] as number,
-      );
-    } else if (pathCommand === 'S') {
-      const cp1x = paramX1 * 2 - paramX2;
-      const cp1y = paramY1 * 2 - paramY2;
-
-      totalLength += getCubicLength(
-        lastX,
-        lastY,
-        cp1x,
-        cp1y,
-        normalSegment[1] as number,
-        normalSegment[2] as number,
-        normalSegment[3] as number,
-        normalSegment[4] as number,
-      );
-    } else if (pathCommand === 'C') {
-      totalLength += getCubicLength(
-        lastX,
-        lastY,
-        normalSegment[1] as number,
-        normalSegment[2] as number,
-        normalSegment[3] as number,
-        normalSegment[4] as number,
-        normalSegment[5] as number,
-        normalSegment[6] as number,
-      );
-    } else if (pathCommand === 'T') {
-      paramQX = paramX1 * 2 - paramQX;
-      paramQY = paramY1 * 2 - paramQY;
-      totalLength += getQuadLength(
-        lastX,
-        lastY,
-        paramQX,
-        paramQY,
-        normalSegment[1] as number,
-        normalSegment[2] as number,
-      );
-    } else if (pathCommand === 'Q') {
-      paramQX = normalSegment[1] as number;
-      paramQY = normalSegment[2] as number;
-      totalLength += getQuadLength(
-        lastX,
-        lastY,
-        normalSegment[1] as number,
-        normalSegment[2] as number,
-        normalSegment[3] as number,
-        normalSegment[4] as number,
-      );
-    } else if (pathCommand === 'Z') {
-      totalLength += getLineLength(lastX, lastY, mx, my);
-    }
-
-    // update params
-    [paramX1, paramY1] = pathCommand === 'Z' ? [mx, my] : (normalSegment.slice(-2) as PointTuple);
-    [paramX2, paramY2] =
-      pathCommand === 'C'
-        ? ([normalSegment[3], normalSegment[4]] as PointTuple)
-        : pathCommand === 'S'
-        ? ([normalSegment[1], normalSegment[2]] as PointTuple)
-        : [paramX1, paramY1];
-  });
-
-  return totalLength;
-};
-
-export default getTotalLength;

package/src/util/isAbsoluteArray.ts

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

@@ -1,15 +0,0 @@
-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 path the `Array` to be checked
- * @returns iteration result
- */
-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.ts

@@ -1,16 +0,0 @@
-import type { NormalArray } from '../types';
-import isAbsoluteArray from './isAbsoluteArray';
-
-/**
- * Iterates an array to check if it's a `pathArray`
- * with all segments are in non-shorthand notation
- * with absolute values.
- *
- * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
- * @returns {boolean} iteration result
- */
-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

@@ -1,24 +0,0 @@
-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) &&
-        (seg.slice(1) as unknown[]).every(Number.isFinite)
-      );
-    }) &&
-    path.length > 0
-  );
-};
-export default isPathArray;

package/src/util/isPointInStroke.ts

@@ -1,16 +0,0 @@
-import type { PathArray } from '../types';
-import getPropertiesAtPoint from './getPropertiesAtPoint';
-import DISTANCE_EPSILON from './distanceEpsilon';
-
-/**
- * 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) < DISTANCE_EPSILON; // 0.01 might be more permissive
-};
-export default isPointInStroke;

package/src/util/isRelativeArray.ts

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

@@ -1,27 +0,0 @@
-import scanSegment from '../parser/scanSegment';
-import skipSpaces from '../parser/skipSpaces';
-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 pathString the path string to be parsed
- * @returns the path string validity
- */
-const isValidPath = (pathString: string) => {
-  if (typeof pathString !== 'string' || !pathString.length) {
-    return false;
-  }
-
-  const path = new PathParser(pathString);
-
-  skipSpaces(path);
-
-  while (path.index < path.max && !path.err.length) {
-    scanSegment(path);
-  }
-
-  return !path.err.length && 'mM'.includes(path.segments[0][0]);
-};
-export default isValidPath;

package/src/util/shapeParams.ts

@@ -1,16 +0,0 @@
-import type { ShapeParams } from '../interface';
-
-/**
- * Supported shapes and their specific parameters.
- */
-const shapeParams: 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 default shapeParams;

package/src/util/shapeToPath.ts

@@ -1,86 +0,0 @@
-import type { ShapeParams } from '../interface';
-import type { ShapeOps, ShapeTypes } from '../types';
-import pathToString from '../convert/pathToString';
-import defaultOptions from '../options/options';
-import error from '../parser/error';
-import isValidPath from './isValidPath';
-import shapeToPathArray from './shapeToPathArray';
-import shapeParams from './shapeParams';
-
-/**
- * Returns a new `<path>` element created from attributes of a `<line>`, `<polyline>`,
- * `<polygon>`, `<rect>`, `<ellipse>`, `<circle>` or `<glyph>`. If `replace` parameter
- * is `true`, it will replace the target. The default `ownerDocument` is your current
- * `document` browser page, if you want to use in server-side using `jsdom`, you can
- * pass the `jsdom` `document` to `ownDocument`.
- *
- * It can also work with an options object, see the type below
- *
- * @see ShapeOps
- *
- * The newly created `<path>` element keeps all non-specific
- * attributes like `class`, `fill`, etc.
- *
- * @param element target shape
- * @param replace option to replace target
- * @param ownerDocument document for create element
- * @return the newly created `<path>` element
- */
-const shapeToPath = (
-  element: ShapeTypes | ShapeOps,
-  replace?: boolean,
-  ownerDocument?: Document,
-): SVGPathElement | false => {
-  const doc = ownerDocument || document;
-  const win = doc.defaultView || /* istanbul ignore next */ window;
-  const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];
-  const targetIsElement = element instanceof win.SVGElement;
-  const tagName = targetIsElement ? element.tagName : null;
-
-  if (tagName === 'path') throw TypeError(`${error}: "${tagName}" is already SVGPathElement`);
-  if (tagName && supportedShapes.every(s => tagName !== s)) throw TypeError(`${error}: "${tagName}" is not SVGElement`);
-
-  const path = doc.createElementNS('http://www.w3.org/2000/svg', 'path');
-  const type = (targetIsElement ? tagName : element.type) as ShapeOps['type'];
-  const shapeAttrs = shapeParams[type] as string[];
-  const config = { type } as Record<string, string>;
-
-  // set d
-  const round = defaultOptions.round as number;
-  const pathArray = shapeToPathArray(element, doc);
-  const description = pathArray && pathArray.length ? pathToString(pathArray, round) : '';
-
-  if (targetIsElement) {
-    shapeAttrs.forEach(p => {
-      config[p] = element.getAttribute(p) as string;
-    });
-    // set no-specific shape attributes: fill, stroke, etc
-    Object.values(element.attributes).forEach(({ name, value }) => {
-      if (!shapeAttrs.includes(name)) path.setAttribute(name, value);
-    });
-  } else {
-    Object.assign(config, element);
-    // set no-specific shape attributes: fill, stroke, etc
-    Object.keys(config).forEach(k => {
-      if (!shapeAttrs.includes(k) && k !== 'type') {
-        path.setAttribute(
-          k.replace(/[A-Z]/g, m => `-${m.toLowerCase()}`),
-          config[k],
-        );
-      }
-    });
-  }
-
-  // replace target element
-  if (isValidPath(description)) {
-    path.setAttribute('d', description);
-    if (replace && targetIsElement) {
-      element.before(path, element);
-      element.remove();
-    }
-    return path;
-  }
-  return false;
-};
-
-export default shapeToPath;