svg-path-commander 1.0.2 → 1.0.5

package/README.md

@@ -1,16 +1,16 @@
 # SVGPathCommander
 [![Coverage Status](https://coveralls.io/repos/github/thednp/svg-path-commander/badge.svg)](https://coveralls.io/github/thednp/svg-path-commander)
-![cypress version](https://img.shields.io/badge/cypress-9.6.0-brightgreen)
-![typescript version](https://img.shields.io/badge/typescript-4.5.2-brightgreen)
 [![ci](https://github.com/thednp/svg-path-commander/actions/workflows/ci.yml/badge.svg)](https://github.com/thednp/svg-path-commander/actions/workflows/ci.yml)
+[![NPM Version](https://img.shields.io/npm/v/svg-path-commander.svg)](https://www.npmjs.com/package/svg-path-commander)
+[![NPM Downloads](https://img.shields.io/npm/dm/svg-path-commander.svg)](http://npm-stat.com/charts.html?svg-path-commander)
+[![jsDeliver](https://img.shields.io/jsdelivr/npm/hw/svg-path-commander)](https://www.jsdelivr.com/package/npm/svg-path-commander)
+![cypress version](https://img.shields.io/badge/cypress-9.6.1-brightgreen)
+![typescript version](https://img.shields.io/badge/typescript-4.5.2-brightgreen)
 
 ![image](./docs/assets/SVGPathCommander.svg)
 
 A modern set of ES6+ JavaScript tools for manipulating the `d` (description) attribute for *SVGPathElement* items. The library is implementing modern JavaScript API to produce reusable path strings with lossless quality. In addition, you also have a powerful tool to convert other SVG shapes like `<circle>` or `<rect>` to `<path>`.
 
-[![NPM Version](https://img.shields.io/npm/v/svg-path-commander.svg?style=flat-square)](https://www.npmjs.com/package/svg-path-commander)
-[![NPM Downloads](https://img.shields.io/npm/dm/svg-path-commander.svg?style=flat-square)](http://npm-stat.com/charts.html?svg-path-commander)
-[![jsDeliver](https://data.jsdelivr.com/v1/package/npm/svg-path-commander/badge)](https://www.jsdelivr.com/package/npm/svg-path-commander)
 
 While you may find familiar tools inside, this library brings ***new additions***:
 * the build in `getBBox`, `getPointAtLength` and `getTotalLength` are more reliable and much more accurate than the native methods, not to mention their world class performance ratings;

package/dist/svg-path-commander.es5.js

@@ -1,5 +1,5 @@
 /*!
-* SVGPathCommander v1.0.2 (http://thednp.github.io/svg-path-commander)
+* SVGPathCommander v1.0.5 (http://thednp.github.io/svg-path-commander)
 * Copyright 2022 © thednp
 * Licensed under MIT (https://github.com/thednp/svg-path-commander/blob/master/LICENSE)
 */
@@ -37,7 +37,16 @@
     var data = path.data;
 
     while (data.length >= paramsCount[LK]) {
-      path.segments.push([pathCommand ].concat( data.splice(0, paramsCount[LK])));
+      // overloaded `moveTo`
+      // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts
+      if (LK === 'm' && data.length > 2) {
+        path.segments.push([pathCommand ].concat( data.splice(0, 2)));
+        LK = 'l';
+        pathCommand = pathCommand === 'm' ? 'l' : 'L';
+      } else {
+        path.segments.push([pathCommand ].concat( data.splice(0, paramsCount[LK])));
+      }
+
       if (!paramsCount[LK]) {
         break;
       }
@@ -348,7 +357,6 @@
    */
   function PathParser(pathString) {
     /** @type {SVGPath.pathArray} */
-    // @ts-ignore
     this.segments = [];
     /** @type {string} */
     this.pathValue = pathString;
@@ -384,7 +392,7 @@
    * of segments we like to call `pathArray`.
    *
    * @param {SVGPath.pathArray | string} pathInput the string to be parsed
-   * @returns {SVGPath.pathArray | string} the resulted `pathArray`
+   * @returns {SVGPath.pathArray | string} the resulted `pathArray` or error string
    */
   function parsePathString(pathInput) {
     if (isPathArray(pathInput)) {
@@ -411,7 +419,7 @@
    */
   function isAbsoluteArray(path) {
     return isPathArray(path)
-      // @ts-ignore -- `isPathArray` also checks if it's `Array`
+      // `isPathArray` also checks if it's `Array`
       && path.every(function (ref) {
         var x = ref[0];
 
@@ -429,7 +437,7 @@
   function pathToAbsolute(pathInput) {
     /* istanbul ignore else */
     if (isAbsoluteArray(pathInput)) {
-      // @ts-ignore -- `isAbsoluteArray` checks if it's `pathArray`
+      // `isAbsoluteArray` checks if it's `pathArray`
       return clonePath(pathInput);
     }
 
@@ -437,14 +445,13 @@
     var x = 0; var y = 0;
     var mx = 0; var my = 0;
 
-    // @ts-ignore -- the `absoluteSegment[]` is for sure an `absolutePath`
+    // the `absoluteSegment[]` is for sure an `absolutePath`
     return path.map(function (segment) {
       var assign, assign$1, assign$2;
 
       var values = segment.slice(1).map(Number);
       var pathCommand = segment[0];
       /** @type {SVGPath.absoluteCommand} */
-      // @ts-ignore
       var absCommand = pathCommand.toUpperCase();
 
       if (pathCommand === 'M') {
@@ -454,7 +461,6 @@
         return ['M', x, y];
       }
       /** @type {SVGPath.absoluteSegment} */
-      // @ts-ignore
       var absoluteSegment = [];
 
       if (pathCommand !== absCommand) {
@@ -474,12 +480,11 @@
             // use brakets for `eslint: no-case-declaration`
             // https://stackoverflow.com/a/50753272/803358
             var absValues = values.map(function (n, j) { return n + (j % 2 ? y : x); });
-            // @ts-ignore for n, l, c, s, q, t
+            // for n, l, c, s, q, t
             absoluteSegment = [absCommand ].concat( absValues);
           }
         }
       } else {
-        // @ts-ignore
         absoluteSegment = [absCommand ].concat( values);
       }
 
@@ -490,17 +495,13 @@
           y = my;
           break;
         case 'H':
-          // @ts-ignore
           (assign$1 = absoluteSegment, x = assign$1[1]);
           break;
         case 'V':
-          // @ts-ignore
           (assign$2 = absoluteSegment, y = assign$2[1]);
           break;
         default:
-          // @ts-ignore
           x = absoluteSegment[segLength - 2];
-          // @ts-ignore
           y = absoluteSegment[segLength - 1];
 
           if (absCommand === 'M') {
@@ -521,7 +522,7 @@
    */
   function isRelativeArray(path) {
     return isPathArray(path)
-      // @ts-ignore -- `isPathArray` checks if it's `Array`
+      // `isPathArray` checks if it's `Array`
       && path.slice(1).every(function (ref) {
         var pc = ref[0];
 
@@ -628,13 +629,45 @@
       while (segment.length) {
         // if created multiple C:s, their original seg is saved
         allPathCommands[i] = 'A';
-        // @ts-ignore
         path.splice(ni += 1, 0, ['C' ].concat( segment.splice(0, 6)));
       }
       path.splice(i, 1);
     }
   }
 
+  /**
+   * 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
+   */
+  function isNormalizedArray(path) {
+    // `isAbsoluteArray` also checks if it's `Array`
+    return isAbsoluteArray(path) && path.every(function (ref) {
+      var pc = ref[0];
+
+      return 'ACLMQZ'.includes(pc);
+    });
+  }
+
+  /**
+   * Iterates an array to check if it's a `pathArray`
+   * with all C (cubic bezier) segments.
+   *
+   * @param {string | SVGPath.pathArray} path the `Array` to be checked
+   * @returns {boolean} iteration result
+   */
+  function isCurveArray(path) {
+    // `isPathArray` also checks if it's `Array`
+    return isNormalizedArray(path) && path.every(function (ref) {
+      var pc = ref[0];
+
+      return 'MC'.includes(pc);
+    });
+  }
+
   /**
    * Normalizes a single segment of a `pathArray` object.
    *
@@ -683,23 +716,6 @@
     return result;
   }
 
-  /**
-   * 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
-   */
-  function isNormalizedArray(path) {
-    // @ts-ignore -- `isAbsoluteArray` also checks if it's `Array`
-    return isAbsoluteArray(path) && path.every(function (ref) {
-      var pc = ref[0];
-
-      return 'ACLMQZ'.includes(pc);
-    });
-  }
-
   /**
    * @type {SVGPath.parserParams}
    */
@@ -748,55 +764,6 @@
     return path;
   }
 
-  /**
-   * Checks a `pathArray` for an unnecessary `Z` segment
-   * and returns a new `pathArray` without it.
-   *
-   * The `pathInput` must be a single path, without
-   * sub-paths. For multi-path `<path>` elements,
-   * use `splitPath` first and apply this utility on each
-   * sub-path separately.
-   *
-   * @param {SVGPath.pathArray | string} pathInput the `pathArray` source
-   * @return {SVGPath.pathArray} a fixed `pathArray`
-   */
-  function fixPath(pathInput) {
-    var pathArray = parsePathString(pathInput);
-    var normalArray = normalizePath(pathArray);
-    var length = pathArray.length;
-    var isClosed = normalArray.slice(-1)[0][0] === 'Z';
-    var segBeforeZ = isClosed ? length - 2 : length - 1;
-
-    var ref = normalArray[0].slice(1);
-    var mx = ref[0];
-    var my = ref[1];
-    var ref$1 = normalArray[segBeforeZ].slice(-2);
-    var x = ref$1[0];
-    var y = ref$1[1];
-
-    /* istanbul ignore else */
-    if (isClosed && mx === x && my === y) {
-      return pathArray.slice(0, -1);
-    }
-    return pathArray;
-  }
-
-  /**
-   * Iterates an array to check if it's a `pathArray`
-   * with all C (cubic bezier) segments.
-   *
-   * @param {string | SVGPath.pathArray} path the `Array` to be checked
-   * @returns {boolean} iteration result
-   */
-  function isCurveArray(path) {
-    // @ts-ignore -- `isPathArray` also checks if it's `Array`
-    return isNormalizedArray(path) && path.every(function (ref) {
-      var pc = ref[0];
-
-      return 'MC'.includes(pc);
-    });
-  }
-
   /**
    * Returns an {x,y} vector rotated by a given
    * angle in radian.
@@ -873,9 +840,9 @@
       cx = ((k * rx * y) / ry) + ((x1 + x2) / 2);
       cy = ((k * -ry * x) / rx) + ((y1 + y2) / 2);
       // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise
-      f1 = (Math.asin((((y1 - cy) / ry))) * (Math.pow( 10, 9 )) >> 0) / (Math.pow( 10, 9 ));
+      f1 = Math.asin((((y1 - cy) / ry) * (Math.pow( 10, 9 )) >> 0) / (Math.pow( 10, 9 )));
       // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise
-      f2 = (Math.asin((((y2 - cy) / ry))) * (Math.pow( 10, 9 )) >> 0) / (Math.pow( 10, 9 ));
+      f2 = Math.asin((((y2 - cy) / ry) * (Math.pow( 10, 9 )) >> 0) / (Math.pow( 10, 9 )));
 
       f1 = x1 < cx ? Math.PI - f1 : f1;
       f2 = x2 < cx ? Math.PI - f2 : f2;
@@ -997,7 +964,7 @@
 
     /* istanbul ignore else */
     if (typeof distance === 'number') {
-      if (distance === 0) {
+      if (distance <= 0) {
         point = { x: x1, y: y1 };
       } else if (distance >= length) {
         point = { x: x2, y: y2 };
@@ -1044,13 +1011,10 @@
     var p5 = midPoint(p3, p4, t);
     var p6 = midPoint(p4, p5, t);
     var seg1 = p0.concat( p2, p4, p6, [t]);
-    // @ts-ignore
     var cp1 = segmentLineFactory.apply(void 0, seg1).point;
     var seg2 = p6.concat( p5, p3, p1, [0]);
-    // @ts-ignore
     var cp2 = segmentLineFactory.apply(void 0, seg2).point;
 
-    // @ts-ignore
     return [cp1.x, cp1.y, cp2.x, cp2.y, x2, y2];
   }
 
@@ -1113,11 +1077,12 @@
 
     /* istanbul ignore else */
     if (isCurveArray(pathInput)) {
-      // @ts-ignore -- `isCurveArray` checks if it's `pathArray`
+      // `isCurveArray` checks if it's `pathArray`
       return clonePath(pathInput);
     }
 
-    var path = fixPath(normalizePath(pathInput));
+    // const path = fixPath(normalizePath(pathInput));
+    var path = normalizePath(pathInput);
     var params = Object.assign({}, paramsParser);
     var allPathCommands = [];
     var pathCommand = ''; // ts-lint
@@ -1140,7 +1105,6 @@
       params.y2 = +(segment[seglen - 3]) || params.y1;
     }
 
-    // @ts-ignore
     return path;
   }
 
@@ -1207,7 +1171,7 @@
       var segment = seg.seg;
       var data = seg.n;
       var prevSeg = i && path[i - 1];
-      var nextSeg = path[i + 1] && path[i + 1];
+      var nextSeg = path[i + 1];
       var pathCommand = seg.c;
       var pLen = path.length;
       /** @type {number} */
@@ -1231,7 +1195,7 @@
           }
           break;
         case 'S':
-          if ((prevSeg && 'CS'.includes(prevSeg.c)) && (!nextSeg || (nextSeg && nextSeg.c !== 'S'))) {
+          if ((prevSeg && 'CS'.includes(prevSeg.c)) && (!nextSeg || nextSeg.c !== 'S')) {
             result = ['C', data[3], data[4], data[1], data[2], x, y];
           } else {
             result = [pathCommand, data[1], data[2], x, y];
@@ -1245,7 +1209,7 @@
           }
           break;
         case 'T':
-          if ((prevSeg && 'QT'.includes(prevSeg.c)) && (!nextSeg || (nextSeg && nextSeg.c !== 'T'))) {
+          if ((prevSeg && 'QT'.includes(prevSeg.c)) && (!nextSeg || nextSeg.c !== 'T')) {
             result = ['Q', data[1], data[2], x, y];
           } else {
             result = [pathCommand, x, y];
@@ -1964,7 +1928,7 @@
     m.m31 = 0; m.m32 = 0; m.m33 = 1; m.m34 = 0;
     m.m41 = 0; m.m42 = 0; m.m43 = 0; m.m44 = 1;
 
-    if (args && args.length) {
+    if (args.length) {
       var ARGS = [16, 6].some(function (l) { return l === args.length; }) ? args : args[0];
 
       return m.setMatrixValue(ARGS);
@@ -2268,9 +2232,7 @@
     toArray: toArray,
   });
 
-  var version$1 = "1.0.2";
-
-  // @ts-ignore
+  var version$1 = "1.0.3";
 
   /**
    * A global namespace for library version.
@@ -2278,6 +2240,8 @@
    */
   var Version$1 = version$1;
 
+  /** @typedef {import('../types/index')} */
+
   Object.assign(CSSMatrix, { Version: Version$1 });
 
   /**
@@ -2677,7 +2641,7 @@
     var POINT = { x: 0, y: 0 };
     var POINTS = [{ x: x, y: y }];
 
-    if (distanceIsNumber && distance === 0) {
+    if (distanceIsNumber && distance <= 0) {
       POINT = { x: x, y: y };
     }
 
@@ -2775,7 +2739,7 @@
     var POINT = { x: 0, y: 0 };
     var POINTS = [{ x: x, y: y }];
 
-    if (distanceIsNumber && distance === 0) {
+    if (distanceIsNumber && distance <= 0) {
       POINT = { x: x, y: y };
     }
 
@@ -2869,7 +2833,7 @@
     var POINT = { x: 0, y: 0 };
     var POINTS = [{ x: x, y: y }];
 
-    if (distanceIsNumber && distance === 0) {
+    if (distanceIsNumber && distance <= 0) {
       POINT = { x: x, y: y };
     }
 
@@ -2926,10 +2890,9 @@
 
     var path = normalizePath(pathInput);
     var distanceIsNumber = typeof distance === 'number';
-    var isM = true;
-    /** @type {number[]} */
+    var isM;
     var data = [];
-    var pathCommand = 'M';
+    var pathCommand;
     var x = 0;
     var y = 0;
     var mx = 0;
@@ -3079,6 +3042,8 @@
    * @returns {SVGPathCommander} a new SVGPathCommander instance
    */
   var SVGPathCommander = function SVGPathCommander(pathValue, config) {
+    var assign;
+
     var instanceOptions = config || {};
 
     var undefPath = typeof pathValue === 'undefined';
@@ -3105,19 +3070,22 @@
     var cz = ref.cz;
 
     // set instance options.round
-    var round = defaultOptions.round;
-    var origin = defaultOptions.origin;
     var roundOption = instanceOptions.round;
     var originOption = instanceOptions.origin;
+    var round;
 
     if (roundOption === 'auto') {
       var pathScale = (("" + (Math.floor(Math.max(width, height))))).length;
       round = pathScale >= 4 ? 0 : 4 - pathScale;
     } else if (Number.isInteger(roundOption) || roundOption === 'off') {
       round = roundOption;
+    } else {
+      ((assign = defaultOptions, round = assign.round));
     }
 
     // set instance options.origin
+    // the SVGPathCommander class will always override the default origin
+    var origin;
     if (Array.isArray(originOption) && originOption.length >= 2) {
       var ref$1 = originOption.map(Number);
       var originX = ref$1[0];
@@ -3131,10 +3099,9 @@
       origin = [cx, cy, cz];
     }
 
-    /**
-     * @type {number | 'off'}
-     */
+    /** @type {number | 'off'} */
     this.round = round;
+    /** @type {[number, number, number=]} */
     this.origin = origin;
 
     return this;
@@ -3218,7 +3185,6 @@
     var split = splitPath(segments);
     var subPath = split.length > 1 ? split : 0;
 
-    // @ts-ignore
     var absoluteMultiPath = subPath && clonePath(subPath).map(function (x, i) {
       if (onlySubpath) {
         return i ? reversePath(x) : parsePathString(x);
@@ -3478,9 +3444,9 @@
       return dx * dx + dy * dy;
     };
     var precision = 8;
-    var scan = { x: 0, y: 0 };
+    var scan;
     var scanDistance = 0;
-    var closest = scan;
+    var closest;
     var bestLength = 0;
     var bestDistance = Infinity;
 
@@ -3497,8 +3463,8 @@
 
     // binary search for precise estimate
     precision /= 2;
-    var before = { x: 0, y: 0 };
-    var after = before;
+    var before;
+    var after;
     var beforeLength = 0;
     var afterLength = 0;
     var beforeDistance = 0;
@@ -3818,10 +3784,37 @@
   }
 
   /**
-   * Must have at least one import of the main namespace.
-   * @typedef {import('../../types/index')}
-   * @typedef {import('../types/index')}
+   * Checks a `pathArray` for an unnecessary `Z` segment
+   * and returns a new `pathArray` without it.
+   *
+   * The `pathInput` must be a single path, without
+   * sub-paths. For multi-path `<path>` elements,
+   * use `splitPath` first and apply this utility on each
+   * sub-path separately.
+   *
+   * @param {SVGPath.pathArray | string} pathInput the `pathArray` source
+   * @return {SVGPath.pathArray} a fixed `pathArray`
    */
+  function fixPath(pathInput) {
+    var pathArray = parsePathString(pathInput);
+    var normalArray = normalizePath(pathArray);
+    var length = pathArray.length;
+    var isClosed = normalArray.slice(-1)[0][0] === 'Z';
+    var segBeforeZ = isClosed ? length - 2 : length - 1;
+
+    var ref = normalArray[0].slice(1);
+    var mx = ref[0];
+    var my = ref[1];
+    var ref$1 = normalArray[segBeforeZ].slice(-2);
+    var x = ref$1[0];
+    var y = ref$1[1];
+
+    /* istanbul ignore else */
+    if (isClosed && mx === x && my === y) {
+      return pathArray.slice(0, -1);
+    }
+    return pathArray;
+  }
 
   /**
    * @interface
@@ -3864,7 +3857,7 @@
     options: defaultOptions,
   };
 
-  var version = "1.0.2";
+  var version = "1.0.5";
 
   /**
    * A global namespace for library version.
@@ -3872,6 +3865,8 @@
    */
   var Version = version;
 
+  /** @typedef {import('../types/index')} */
+
   // Export to global
   Object.assign(SVGPathCommander, Util, { Version: Version });