svg-path-commander 2.1.2 → 2.1.5

package/src/process/transformPath.ts

@@ -1,110 +0,0 @@
-import getSVGMatrix from './getSVGMatrix';
-import projection2d from './projection2d';
-import defaultOptions from '../options/options';
-import type { AbsoluteArray, AbsoluteSegment, CSegment, LSegment, PathArray, TransformObjectValues } from '../types';
-import type { TransformObject } from '../interface';
-import iterate from './iterate';
-import parsePathString from '../parser/parsePathString';
-import segmentToCubic from './segmentToCubic';
-import normalizeSegment from './normalizeSegment';
-import paramsParser from '../parser/paramsParser';
-import absolutizeSegment from './absolutizeSegment';
-
-/**
- * Apply a 2D / 3D transformation to a `pathArray` instance.
- *
- * Since *SVGElement* doesn't support 3D transformation, this function
- * creates a 2D projection of the <path> element.
- *
- * @param path the `pathArray` to apply transformation
- * @param transform the transform functions `Object`
- * @returns the resulted `pathArray`
- */
-const transformPath = (pathInput: PathArray | string, transform?: Partial<TransformObject>) => {
-  // last x and y transformed values
-  let x = 0;
-  let y = 0;
-  // new x and y transformed
-  let lx = 0;
-  let ly = 0;
-  // segment params iteration index and length
-  let j = 0;
-  let jj = 0;
-  let pathCommand = 'M';
-  // transform uses it's own set of params
-  const transformParams = { ...paramsParser };
-  const path = parsePathString(pathInput);
-  const transformProps = transform && Object.keys(transform);
-
-  // when used as a static method, invalidate somehow
-  if (!transform || (transformProps && !transformProps.length)) return path.slice(0) as typeof path;
-
-  // transform origin is extremely important
-  if (!transform.origin) {
-    Object.assign(transform, { origin: defaultOptions.origin });
-  }
-  const origin = transform.origin as [number, number, number];
-  const matrixInstance = getSVGMatrix(transform as TransformObjectValues);
-
-  if (matrixInstance.isIdentity) return path.slice(0) as typeof path;
-
-  return iterate<AbsoluteArray>(path, (seg, index, lastX, lastY) => {
-    transformParams.x = lastX;
-    transformParams.y = lastY;
-    [pathCommand] = seg;
-    const absCommand = pathCommand.toUpperCase();
-    const isRelative = absCommand !== pathCommand;
-    const absoluteSegment = isRelative
-      ? absolutizeSegment(seg, index, lastX, lastY)
-      : (seg.slice(0) as AbsoluteSegment);
-
-    let result =
-      absCommand === 'A'
-        ? segmentToCubic(absoluteSegment, transformParams)
-        : ['V', 'H'].includes(absCommand)
-        ? normalizeSegment(absoluteSegment, transformParams)
-        : absoluteSegment;
-
-    // update pathCommand
-    pathCommand = result[0];
-    const isLongArc = pathCommand === 'C' && result.length > 7;
-    const tempSegment = (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;
-
-    if (isLongArc) {
-      path.splice(index + 1, 0, ['C' as typeof pathCommand | number].concat(result.slice(7)) as CSegment);
-      result = tempSegment as CSegment;
-    }
-
-    if (pathCommand === 'L') {
-      [lx, ly] = projection2d(matrixInstance, [(result as LSegment)[1], (result as LSegment)[2]], origin);
-
-      /* istanbul ignore else @preserve */
-      if (x !== lx && y !== ly) {
-        result = ['L', lx, ly];
-      } else if (y === ly) {
-        result = ['H', lx];
-      } else if (x === lx) {
-        result = ['V', ly];
-      }
-    } else {
-      for (j = 1, jj = result.length; j < jj; j += 2) {
-        [lx, ly] = projection2d(matrixInstance, [+result[j], +result[j + 1]], origin);
-        result[j] = lx;
-        result[j + 1] = ly;
-      }
-    }
-    // now update x and y
-    x = lx;
-    y = ly;
-
-    const seglen = tempSegment.length;
-    transformParams.x1 = +tempSegment[seglen - 2];
-    transformParams.y1 = +tempSegment[seglen - 1];
-    transformParams.x2 = +tempSegment[seglen - 4] || transformParams.x1;
-    transformParams.y2 = +tempSegment[seglen - 3] || transformParams.y1;
-
-    return result;
-  });
-};
-
-export default transformPath;

package/src/types.ts

@@ -1,228 +0,0 @@
-import type { LineAttr, CircleAttr, PolyAttr, RectAttr, EllipseAttr, GlyphAttr, TransformObject } from './interface';
-
-export type SpaceNumber =
-  | 0x1680
-  | 0x180e
-  | 0x2000
-  | 0x2001
-  | 0x2002
-  | 0x2003
-  | 0x2004
-  | 0x2005
-  | 0x2006
-  | 0x2007
-  | 0x2008
-  | 0x2009
-  | 0x200a
-  | 0x202f
-  | 0x205f
-  | 0x3000
-  | 0xfeff
-  | 0x0a
-  | 0x0d
-  | 0x2028
-  | 0x2029
-  | 0x20
-  | 0x09
-  | 0x0b
-  | 0x0c
-  | 0xa0
-  | 0x1680;
-
-export type PathCommandNumber = 0x6d | 0x7a | 0x6c | 0x68 | 0x76 | 0x63 | 0x73 | 0x71 | 0x74 | 0x61;
-
-export type DigitNumber = 0x30 | 0x31 | 0x32 | 0x33 | 0x34 | 0x35 | 0x36 | 0x37 | 0x38 | 0x39;
-
-// custom types
-export type MCommand = 'M';
-export type mCommand = 'm';
-
-export type LCommand = 'L';
-export type lCommand = 'l';
-
-export type VCommand = 'V';
-export type vCommand = 'v';
-
-export type HCommand = 'H';
-export type hCommand = 'h';
-
-export type ZCommand = 'Z';
-export type zCommand = 'z';
-
-export type CCommand = 'C';
-export type cCommand = 'c';
-
-export type SCommand = 'S';
-export type sCommand = 's';
-
-export type QCommand = 'Q';
-export type qCommand = 'q';
-
-export type TCommand = 'T';
-export type tCommand = 't';
-
-export type ACommand = 'A';
-export type aCommand = 'a';
-
-export type AbsoluteCommand =
-  | MCommand
-  | LCommand
-  | VCommand
-  | HCommand
-  | ZCommand
-  | CCommand
-  | SCommand
-  | QCommand
-  | TCommand
-  | ACommand;
-
-export type RelativeCommand =
-  | mCommand
-  | lCommand
-  | vCommand
-  | hCommand
-  | zCommand
-  | cCommand
-  | sCommand
-  | qCommand
-  | tCommand
-  | aCommand;
-
-export type PathCommand = AbsoluteCommand | RelativeCommand;
-
-export type MSegment = [MCommand, number, number];
-export type mSegment = [mCommand, number, number];
-export type MoveSegment = MSegment | mSegment;
-
-export type LSegment = [LCommand, number, number];
-export type lSegment = [lCommand, number, number];
-export type LineSegment = LSegment | lSegment;
-
-export type VSegment = [VCommand, number];
-export type vSegment = [vCommand, number];
-export type VertLineSegment = vSegment | VSegment;
-
-export type HSegment = [HCommand, number];
-export type hSegment = [hCommand, number];
-export type HorLineSegment = HSegment | hSegment;
-
-export type ZSegment = [ZCommand];
-export type zSegment = [zCommand];
-export type CloseSegment = ZSegment | zSegment;
-
-export type CSegment = [CCommand, number, number, number, number, number, number];
-export type cSegment = [cCommand, number, number, number, number, number, number];
-export type CubicSegment = CSegment | cSegment;
-
-export type SSegment = [SCommand, number, number, number, number];
-export type sSegment = [sCommand, number, number, number, number];
-export type ShortCubicSegment = SSegment | sSegment;
-
-export type QSegment = [QCommand, number, number, number, number];
-export type qSegment = [qCommand, number, number, number, number];
-export type QuadSegment = QSegment | qSegment;
-
-export type TSegment = [TCommand, number, number];
-export type tSegment = [tCommand, number, number];
-export type ShortQuadSegment = TSegment | tSegment;
-
-export type ASegment = [ACommand, number, number, number, number, number, number, number];
-export type aSegment = [aCommand, number, number, number, number, number, number, number];
-export type ArcSegment = ASegment | aSegment;
-
-export type PathSegment =
-  | MoveSegment
-  | LineSegment
-  | VertLineSegment
-  | HorLineSegment
-  | CloseSegment
-  | CubicSegment
-  | ShortCubicSegment
-  | QuadSegment
-  | ShortQuadSegment
-  | ArcSegment;
-
-export type ShortSegment = VertLineSegment | HorLineSegment | ShortCubicSegment | ShortQuadSegment | CloseSegment;
-
-export type AbsoluteSegment =
-  | MSegment
-  | LSegment
-  | VSegment
-  | HSegment
-  | CSegment
-  | SSegment
-  | QSegment
-  | TSegment
-  | ASegment
-  | ZSegment;
-
-export type RelativeSegment =
-  | mSegment
-  | lSegment
-  | vSegment
-  | hSegment
-  | cSegment
-  | sSegment
-  | qSegment
-  | tSegment
-  | aSegment
-  | zSegment;
-
-export type NormalSegment = MSegment | LSegment | CSegment | QSegment | ASegment | ZSegment;
-
-export type PathArray = [MSegment | mSegment, ...PathSegment[]];
-export type AbsoluteArray = [MSegment, ...AbsoluteSegment[]];
-export type RelativeArray = [MSegment, ...RelativeSegment[]];
-export type NormalArray = [MSegment, ...NormalSegment[]];
-export type CurveArray = [MSegment, ...CSegment[]];
-export type PolygonArray = [MSegment, ...LSegment[], ZSegment];
-export type PolylineArray = [MSegment, ...LSegment[]];
-
-export type ShapeTypes =
-  | SVGPolylineElement
-  | SVGPolygonElement
-  | SVGLineElement
-  | SVGEllipseElement
-  | SVGCircleElement
-  | SVGRectElement;
-
-export type ShapeTags = 'line' | 'polyline' | 'polygon' | 'ellipse' | 'circle' | 'rect' | 'glyph';
-
-export type ShapeOps = LineAttr | PolyAttr | PolyAttr | EllipseAttr | CircleAttr | RectAttr | GlyphAttr;
-
-export type TransformObjectValues = Partial<TransformObject> & { origin: [number, number, number] };
-
-export type Point = {
-  x: number;
-  y: number;
-};
-
-export type PointTuple = [number, number];
-
-export type DerivedPoint = Point & { t: number };
-export type QuadPoints = [Point, Point, Point, Point, Point, Point];
-export type CubicPoints = [Point, Point, Point, Point, Point, Point, Point, Point];
-export type DerivedQuadPoints = [DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint, DerivedPoint];
-export type DerivedCubicPoints = [
-  DerivedPoint,
-  DerivedPoint,
-  DerivedPoint,
-  DerivedPoint,
-  DerivedPoint,
-  DerivedPoint,
-  DerivedPoint,
-  DerivedPoint,
-];
-export type QuadCoordinates = [number, number, number, number, number, number];
-export type CubicCoordinates = [number, number, number, number, number, number, number, number];
-export type ArcCoordinates = [number, number, number, number, number, number, number, number, number];
-export type LineCoordinates = [number, number, number, number];
-
-export type DeriveCallback = (t: number) => Point;
-
-export type IteratorCallback = (
-  segment: PathSegment,
-  index: number,
-  lastX: number,
-  lastY: number,
-) => PathSegment | false | void | undefined;

package/src/util/distanceEpsilon.ts

@@ -1,3 +0,0 @@
-const DISTANCE_EPSILON = 0.00001;
-
-export default DISTANCE_EPSILON;

package/src/util/getClosestPoint.ts

@@ -1,15 +0,0 @@
-import type { PathArray } from '../types';
-import getPropertiesAtPoint from './getPropertiesAtPoint';
-
-/**
- * Returns the point in path closest to a given point.
- *
- * @param pathInput target `pathArray`
- * @param point the given point
- * @returns the best match
- */
-const getClosestPoint = (pathInput: string | PathArray, point: { x: number; y: number }) => {
-  return getPropertiesAtPoint(pathInput, point).closest;
-};
-
-export default getClosestPoint;

package/src/util/getDrawDirection.ts

@@ -1,16 +0,0 @@
-import getPathArea from './getPathArea';
-import pathToCurve from '../convert/pathToCurve';
-import type { PathArray } from '../types';
-
-/**
- * Check if a path is drawn clockwise and returns true if so,
- * false otherwise.
- *
- * @param path the path string or `pathArray`
- * @returns true when clockwise or false if not
- */
-const getDrawDirection = (path: string | PathArray) => {
-  return getPathArea(pathToCurve(path)) >= 0;
-};
-
-export default getDrawDirection;

package/src/util/getPathArea.ts

@@ -1,70 +0,0 @@
-import pathToCurve from '../convert/pathToCurve';
-import type { PointTuple, PathArray } from '../types';
-
-/**
- * Returns the area of a single cubic-bezier segment.
- *
- * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html
- *
- * @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 area of the cubic-bezier segment
- */
-const getCubicSegArea = (
-  x1: number,
-  y1: number,
-  c1x: number,
-  c1y: number,
-  c2x: number,
-  c2y: number,
-  x2: number,
-  y2: number,
-) => {
-  return (
-    (3 *
-      ((y2 - y1) * (c1x + c2x) -
-        (x2 - x1) * (c1y + c2y) +
-        c1y * (x1 - c2x) -
-        c1x * (y1 - c2y) +
-        y2 * (c2x + x1 / 3) -
-        x2 * (c2y + y1 / 3))) /
-    20
-  );
-};
-
-/**
- * Returns the area of a shape.
- *
- * @author Jürg Lehni & Jonathan Puckey
- *
- * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js
- *
- * @param path the shape `pathArray`
- * @returns the length of the cubic-bezier segment
- */
-const getPathArea = (path: PathArray) => {
-  let x = 0;
-  let y = 0;
-  let len = 0;
-
-  return pathToCurve(path)
-    .map(seg => {
-      switch (seg[0]) {
-        case 'M':
-          [, x, y] = seg;
-          return 0;
-        default:
-          len = getCubicSegArea(x, y, seg[1], seg[2], seg[3], seg[4], seg[5], seg[6]);
-          [x, y] = seg.slice(-2) as PointTuple;
-          return len;
-      }
-    })
-    .reduce((a, b) => a + b, 0);
-};
-export default getPathArea;

package/src/util/getPathBBox.ts

@@ -1,98 +0,0 @@
-import iterate from '../process/iterate';
-import { PathBBox } from '../interface';
-import { MSegment, PathArray, Point } from '../types';
-import { getLineBBox } from '../math/lineTools';
-import { getArcBBox } from '../math/arcTools';
-import { getCubicBBox } from '../math/cubicTools';
-import { getQuadBBox } from '../math/quadTools';
-import parsePathString from '../parser/parsePathString';
-import paramsParser from '../parser/paramsParser';
-import normalizeSegment from '../process/normalizeSegment';
-
-const getPathBBox = (pathInput: PathArray | string) => {
-  if (!pathInput) {
-    return {
-      x: 0,
-      y: 0,
-      width: 0,
-      height: 0,
-      x2: 0,
-      y2: 0,
-      cx: 0,
-      cy: 0,
-      cz: 0,
-    };
-  }
-
-  const path = parsePathString(pathInput);
-  let data = [] as number[];
-  let pathCommand = 'M';
-  const x = 0;
-  const y = 0;
-  let mx = 0;
-  let my = 0;
-  const MIN = [] as Point[];
-  const MAX = [] as Point[];
-  let min = { x, y };
-  let max = { x, y };
-  const params = { ...paramsParser };
-
-  iterate(path, (seg, _, lastX, lastY) => {
-    params.x = lastX;
-    params.y = lastY;
-    const result = normalizeSegment(seg, params);
-    [pathCommand] = result;
-    data = [lastX, lastY].concat(result.slice(1) as number[]);
-
-    // this segment is always ZERO
-    /* istanbul ignore else @preserve */
-    if (pathCommand === 'M') {
-      // remember mx, my for Z
-      [, mx, my] = result as MSegment;
-      min = { x: mx, y: my };
-      max = { x: mx, y: my };
-    } else if (pathCommand === 'L') {
-      ({ min, max } = getLineBBox(data[0], data[1], data[2], data[3]));
-    } else if (pathCommand === 'A') {
-      ({ min, max } = getArcBBox(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8]));
-    } else if (pathCommand === 'C') {
-      ({ min, max } = getCubicBBox(data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]));
-    } else if (pathCommand === 'Q') {
-      ({ min, max } = getQuadBBox(data[0], data[1], data[2], data[3], data[4], data[5]));
-    } else if (pathCommand === 'Z') {
-      data = [lastX, lastY, mx, my];
-      ({ min, max } = getLineBBox(data[0], data[1], data[2], data[3]));
-    }
-
-    MIN.push(min);
-    MAX.push(max);
-
-    const seglen = result.length;
-    params.x1 = +result[seglen - 2];
-    params.y1 = +result[seglen - 1];
-    params.x2 = +result[seglen - 4] || params.x1;
-    params.y2 = +result[seglen - 3] || params.y1;
-  });
-
-  const xMin = Math.min(...MIN.map(n => n.x));
-  const xMax = Math.max(...MAX.map(n => n.x));
-  const yMin = Math.min(...MIN.map(n => n.y));
-  const yMax = Math.max(...MAX.map(n => n.y));
-  const width = xMax - xMin;
-  const height = yMax - yMin;
-
-  return {
-    width,
-    height,
-    x: xMin,
-    y: yMin,
-    x2: xMax,
-    y2: yMax,
-    cx: xMin + width / 2,
-    cy: yMin + height / 2,
-    // an estimated guess
-    cz: Math.max(width, height) + Math.min(width, height) / 2,
-  } satisfies PathBBox;
-};
-
-export default getPathBBox;

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;