svg-path-commander 2.1.0 → 2.1.2

package/test/fixtures/simpleShapes.js

@@ -3,7 +3,7 @@ const simpleShapes = {
     'M10 10l80 80V10H50', // line
     'M10 90C30 90 25 10 50 10s20 80 40 80s15 -80 40 -80s20 80 40 80', // cubic
     'M10 50q15 -25 30 0t30 0t30 0t30 0t30 0t30 0', // quad
-    'M6 10a6 4 10 1 0 8 0M6 10a6 4 10 1 1 8 0M6 10a6 4 10 0 1 8 0M6 10a6 4 10 0 0 8 0' // arc
+    'M6 10a6 4 10 1 0 8 0m-8 0a6 4 10 1 1 8 0m-8 0a6 4 10 0 1 8 0m-8 0a6 4 10 0 0 8 0' // arc
   ],
   // {translate: 15, rotate: 15, scale: 0.5}
   normalized: [
@@ -13,32 +13,32 @@ const simpleShapes = {
     "M6 10A6 4 10 1 0 14 10M6 10A6 4 10 1 1 14 10M6 10A6 4 10 0 1 14 10M6 10A6 4 10 0 0 14 10"
   ],
   transformed: [
-    "M50.86 25.51L79.14 74.49L89.49 35.86L70.18 30.68",
-    "M61.19 58.97C70.85 61.55 78.78 22.27 90.86 25.51S90.16 66.73 99.82 69.32S117.42 32.62 129.49 35.86S128.8 77.08 138.46 79.67",
-    "M71.53 38.35Q82.01 28.22 86.02 42.24T100.51 46.12T115 50T129.49 53.88T143.98 57.76T158.47 61.65",
-    "M23.07 9.48C21.4 10.14 21.89 12.25 23.95 13.28C26.02 14.32 28.1 13.5 27.71 11.81C27.61 11.37 27.34 10.92 26.93 10.52M23.07 9.48C21.52 7.97 22.24 6.18 24.36 6.27C26.48 6.35 28.41 8.25 27.84 9.68C27.69 10.05 27.37 10.35 26.93 10.52M23.07 9.48C24.2 9.04 25.88 9.49 26.93 10.52M23.07 9.48C24.12 10.51 25.8 10.96 26.93 10.52"
+    "M18.54 6.12L46.82 55.11L57.17 16.48L37.85 11.3",
+    "M8.18 44.76C17.84 47.35 25.78 8.06 37.85 11.3S37.16 52.53 46.82 55.11S64.42 18.42 76.49 21.65S75.8 62.88 85.46 65.47",
+    "M13.36 25.44Q23.84 15.31 27.85 29.32T42.34 33.21T56.83 37.09T71.31 40.97T85.8 44.85T100.29 48.74",
+    "M16.6 5.61C14.93 6.26 15.42 8.37 17.49 9.41C19.55 10.44 21.64 9.62 21.25 7.93C21.14 7.49 20.87 7.04 20.47 6.64M16.6 5.61C15.06 4.09 15.78 2.3 17.9 2.39C20.02 2.48 21.95 4.37 21.37 5.8C21.22 6.18 20.91 6.47 20.47 6.64M16.6 5.61C17.74 5.16 19.42 5.61 20.47 6.64M16.6 5.61C17.65 6.63 19.33 7.09 20.47 6.64"
   ],
   // {scale: [0.55,0.6,0.65]}
   scaled3d: [
-    "M28 26L72 74V26H50",
-    "M46 74C57 74 54.25 26 68 26S79 74 90 74S98.25 26 112 26S123 74 134 74",
-    "M50.5 50Q58.75 35 67 50T83.5 50T100 50T116.5 50T133 50T149.5 50",
-    "M7.8 10C6.21 11.28 7.33 13.57 9.82 14.13C12.31 14.69 14.29 13.09 13.4 11.25C13.16 10.77 12.74 10.34 12.2 10M7.8 10C5.73 8.72 5.98 6.43 8.26 5.87C10.54 5.31 13.13 6.91 12.92 8.75C12.87 9.23 12.62 9.66 12.2 10M7.8 10C8.88 9.13 10.79 9.13 12.2 10M7.8 10C9.21 10.87 11.12 10.87 12.2 10"
+    "M5.5 6L49.5 54V6H27.5",
+    "M5.5 54C16.5 54 13.75 6 27.5 6S38.5 54 49.5 54S57.75 6 71.5 6S82.5 54 93.5 54",
+    "M5.5 30Q13.75 15 22 30T38.5 30T55 30T71.5 30T88 30T104.5 30",
+    "M3.3 6C1.71 7.28 2.83 9.57 5.32 10.13C7.81 10.69 9.79 9.09 8.9 7.25C8.66 6.77 8.24 6.34 7.7 6M3.3 6C1.23 4.72 1.48 2.43 3.76 1.87C6.04 1.31 8.63 2.91 8.42 4.75C8.37 5.23 8.12 5.66 7.7 6M3.3 6C4.38 5.13 6.29 5.13 7.7 6M3.3 6C4.71 6.87 6.62 6.87 7.7 6"
   ],
   // {skew: 45}
   // {skew: [45,0]}
   skewedX: [
-    "M-30 10L130 90L50 10H10",
-    "M50 90C70 90 -15 10 10 10S110 90 130 90S65 10 90 10S190 90 210 90",
-    "M10 50Q0 25 40 50T70 50T100 50T130 50T160 50T190 50",
-    "M6 10C5.24 12.13 11.11 15.95 16.56 16.88C22.01 17.81 22.96 15.15 18.26 12.09C17.03 11.29 15.55 10.56 14 10M6 10C0.1 7.87 -3.26 4.05 -0.04 3.12C3.17 2.19 10.54 4.85 13.22 7.91C13.93 8.71 14.2 9.44 14 10M6 10C6.52 8.56 10 8.56 14 10M6 10C10 11.44 13.48 11.44 14 10"
+    "M20 10L180 90L100 10H60",
+    "M100 90C120 90 35 10 60 10S160 90 180 90S115 10 140 10S240 90 260 90",
+    "M60 50Q50 25 90 50T120 50T150 50T180 50T210 50T240 50",
+    "M16 10C15.24 12.13 21.11 15.95 26.56 16.88C32.01 17.81 32.96 15.15 28.26 12.09C27.03 11.29 25.55 10.56 24 10M16 10C10.1 7.87 6.74 4.05 9.96 3.12C13.17 2.19 20.54 4.85 23.22 7.91C23.93 8.71 24.2 9.44 24 10M16 10C16.52 8.56 20 8.56 24 10M16 10C20 11.44 23.48 11.44 24 10"
   ],
   // {skew: [0,45]}
   skewedY: [
-    "M10 -30L90 130V50L50 10",
-    "M10 10C30 30 25 -55 50 -30S70 70 90 90S105 25 130 50S150 150 170 170",
-    "M10 -40Q25 -50 40 -10T70 20T100 50T130 80T160 110T190 140",
-    "M6 6C3.11 5.24 5.15 11.11 9.67 16.56C14.2 22.01 17.81 22.96 16.17 18.26C15.75 17.03 14.99 15.55 14 14M6 6C2.23 0.1 2.7 -3.26 6.84 -0.04C10.98 3.17 15.69 10.54 15.31 13.22C15.22 13.93 14.76 14.2 14 14M6 6C7.96 6.52 11.44 10 14 14M6 6C8.56 10 12.04 13.48 14 14"
+    "M10 20L90 180V100L50 60",
+    "M10 100C30 120 25 35 50 60S70 160 90 180S105 115 130 140S150 240 170 260",
+    "M10 60Q25 50 40 90T70 120T100 150T130 180T160 210T190 240",
+    "M6 16C3.11 15.24 5.15 21.11 9.67 26.56C14.2 32.01 17.81 32.96 16.17 28.26C15.75 27.03 14.99 25.55 14 24M6 16C2.23 10.1 2.7 6.74 6.84 9.96C10.98 13.17 15.69 20.54 15.31 23.22C15.22 23.93 14.76 24.2 14 24M6 16C7.96 16.52 11.44 20 14 24M6 16C8.56 20 12.04 23.48 14 24"
   ],
   reversed: [
     "M50 10H90V90L10 10",
@@ -68,7 +68,7 @@ const simpleShapes = {
     { x: 45.35533905932737, y: 45.35533905932737 },
     { x: 28.85808806500117, y: 46.6836898667648 },
     { x: 46.84696090751847, y: 58.807108530914896 },
-    { x: 16.19278384041914, y: 14.935425084181293 }
+    { x: 7.697454886004856, y: 9.193767828563768 }
   ]
 };
 

package/test/static.test.ts

@@ -1,13 +1,11 @@
 import { expect, it, describe, beforeEach, vi } from 'vitest';
-import SVGPathCommander, { type CurveArray, type ShapeTypes } from '~/index';
+import SVGPathCommander, { PathArray, type CurveArray, type ShapeTypes } from '~/index';
 import invalidPathValue from '../src/parser/invalidPathValue';
-import getCubicProperties from '../src/math/cubicTools';
-import getQuadProperties from '../src/math/quadTools';
-import getArcProperties from '../src/math/arcTools';
 import error from '../src/parser/error';
 
 import getMarkup from './fixtures/getMarkup';
 import simpleShapes from './fixtures/simpleShapes';
+import shapes from './fixtures/shapes';
 import shapeObjects from './fixtures/shapeObjects';
 
 import "../docs/assets/style.css";
@@ -117,11 +115,12 @@ describe('SVGPathCommander Static Methods', () => {
     });
   });
 
-  it(`Can revert back to default round option`, () => {
-    const sample = [["M", 0, 0], ["L", 181.99955, 0], ["L", 91, 72], ["L", 0, 0], ["Z"]];
-    const rounded = [["M", 0, 0], ["L", 181.9996, 0], ["L", 91, 72], ["L", 0, 0], ["Z"]];
+  it(`Can disable round, use a given decimal amount or revert back to default round option`, () => {
+    const sample = [["M", 0, 0], ["L", 181.99955, 0], ["L", 91, 72], ["L", 0, 0], ["Z"]] as PathArray;
+    const rounded = [["M", 0, 0], ["L", 181.9996, 0], ["L", 91, 72], ["L", 0, 0], ["Z"]] as PathArray;
 
-    // @ts-expect-error
+    expect(SVGPathCommander.roundPath(sample, 4), `can use number setting`).to.deep.equal(rounded);
+    expect(SVGPathCommander.roundPath(sample, 'off'), `can use "off" setting`).to.deep.equal(sample);
     expect(SVGPathCommander.roundPath(sample, -1), `use 4 decimals when negative number is provided`).to.deep.equal(rounded);
     // @ts-expect-error
     expect(SVGPathCommander.roundPath(sample, 'wombat'), `use 4 decimals when string is provided`).to.deep.equal(rounded);
@@ -200,7 +199,7 @@ describe('SVGPathCommander Static Methods', () => {
     const propsPoint0 = getPropertiesAtPoint(simpleShapes.initial[1], { "x": 10, "y": 90 });
     expect(propsPoint0.closest).to.deep.equal({ x: 10, y: 90 });
     expect(propsPoint0.distance).to.equal(0);
-    expect(propsPoint0.segment).to.deep.equal({ segment: ["M", 10, 90], index: 0, length: 0, point: { x: 10, y: 90 }, lengthAtSegment: 0 })
+    expect(propsPoint0.segment).to.deep.equal({ segment: ["M", 10, 90], index: 0, length: 0, lengthAtSegment: 0 })
 
     // getPropertiesAtPoint mid point
     const propsPoint50 = getPropertiesAtPoint(simpleShapes.initial[1], { x: 30.072453006153214, y: 41.42818552481854 });
@@ -212,7 +211,7 @@ describe('SVGPathCommander Static Methods', () => {
     const propsPoint400 = getPropertiesAtPoint(simpleShapes.initial[1], { "x": 50, "y": 10 });
     expect(propsPoint400.closest).to.deep.equal({ x: 50.000003520199236, y: 10.000000000000531 })
     expect(propsPoint400.distance).to.equal(0.0000035201992361067316)
-    expect(propsPoint400.segment).to.deep.equal({ segment: ['s', 20, 80, 40, 80], index: 2, length: 94.75724347727943, lengthAtSegment: 94.75724347727943})
+    expect(propsPoint400.segment).to.deep.equal({ segment: ['s', 20, 80, 40, 80], index: 2, length: 94.75724347727943, lengthAtSegment: 94.75724347727943 })
   });
 
   it(`Can do getSegmentAtLength`, () => {
@@ -226,9 +225,9 @@ describe('SVGPathCommander Static Methods', () => {
   it(`Can do getSegmentOfPoint`, () => {
     const { getSegmentOfPoint } = SVGPathCommander;
     // first point
-    expect(getSegmentOfPoint(simpleShapes.initial[1], { x: 10, y: 90 })).to.deep.equal({ segment: ["M", 10, 90], index: 0, length: 0, point: { x: 10, y: 90 }, lengthAtSegment: 0 });
+    expect(getSegmentOfPoint(simpleShapes.initial[1], { x: 10, y: 90 })).to.deep.equal({ segment: ["M", 10, 90], index: 0, length: 0, lengthAtSegment: 0 });
     // mid point
-    expect(getSegmentOfPoint(simpleShapes.initial[3], { x: 9, y: 9 })).to.deep.equal({ segment: ["a", 6, 4, 10, 0, 0, 8, 0], index: 7, length: 7.498916687913066,/* point: { x: 6, y: 10 },*/ lengthAtSegment: 55.613707646817915 });
+    expect(getSegmentOfPoint(simpleShapes.initial[3], { x: 9, y: 9 })).to.deep.equal({ segment: ["a", 6, 4, 10, 0, 1, 8, 0], index: 5, length: 7.498916687913066,/* point: { x: 6, y: 10 },*/ lengthAtSegment: 48.11479095890485 });
   });
 
   it(`Can do getClosestPoint`, () => {
@@ -236,7 +235,7 @@ describe('SVGPathCommander Static Methods', () => {
     // first point
     expect(getClosestPoint(simpleShapes.initial[1], { x: 10, y: 90 })).to.deep.equal({ x: 10, y: 90 });
     // mid point
-    expect(getClosestPoint(simpleShapes.initial[3], { x: 9, y: 9 })).to.deep.equal({ x: 8.648537607602185, y: 10.940998877338636 });
+    expect(getClosestPoint(simpleShapes.initial[3], { x: 9, y: 9 })).to.deep.equal({ x: 8.995511191469355, y: 8.952970323068374 });
   });
 
   it(`Can do isPointInStroke`, () => {
@@ -245,7 +244,7 @@ describe('SVGPathCommander Static Methods', () => {
     expect(isPointInStroke(simpleShapes.initial[1], { x: 10, y: 90 })).to.be.true;
     // mid point'
     // expect(isPointInStroke(simpleShapes.initial[1], { x: 28.94438057441916, y: 46.29922469345143 })).to.be.true;
-    expect(isPointInStroke(simpleShapes.initial[1], {x: 90, y: 90})).to.be.true;
+    expect(isPointInStroke(simpleShapes.initial[1], { x: 90, y: 90 })).to.be.true;
     // ({ x: 10, y: 10 })
     expect(isPointInStroke(simpleShapes.initial[1], { x: 10, y: 10 })).to.be.false;
     // ({ x: 45.355339, y: 45.355339 })
@@ -269,13 +268,13 @@ describe('SVGPathCommander Static Methods', () => {
   });
 
   it(`Can do polygonLength`, () => {
-    const { polygonLength } = SVGPathCommander;
-    expect(polygonLength([[100, 100], [150, 25], [150, 75], [200, 0]])).to.equal(230.27756377319946);
+    const { polygonTools } = SVGPathCommander;
+    expect(polygonTools.polygonLength([[100, 100], [150, 25], [150, 75], [200, 0]])).to.equal(230.27756377319946);
   });
 
   it(`Can do polygonArea`, () => {
-    const { polygonArea } = SVGPathCommander;
-    expect(polygonArea([[107.4, 13], [113.7, 28.8], [127.9, 31.3], [117.6, 43.5], [120.1, 60.8], [107.4, 52.6], [94.6, 60.8], [97.1, 43.5], [86.8, 31.3], [101, 28.8]])).to.equal(-836.69);
+    const { polygonTools } = SVGPathCommander;
+    expect(polygonTools.polygonArea([[107.4, 13], [113.7, 28.8], [127.9, 31.3], [117.6, 43.5], [120.1, 60.8], [107.4, 52.6], [94.6, 60.8], [97.1, 43.5], [86.8, 31.3], [101, 28.8]])).to.equal(-836.69);
   });
 
   it(`Can do transformPath with empty object`, () => {
@@ -288,17 +287,44 @@ describe('SVGPathCommander Static Methods', () => {
     expect(path2).to.equal(simpleShapes.normalized[0]);
   });
 
+  it(`Can check path type`, () => {
+    const { parsePathString, isPathArray, isCurveArray, isAbsoluteArray, isRelativeArray, isNormalizedArray } = SVGPathCommander;
+    // const 
+    expect(isPathArray(simpleShapes.initial[0])).to.be.false;
+    expect(isPathArray(parsePathString(simpleShapes.initial[0]))).to.be.true;
+    expect(isAbsoluteArray(simpleShapes.normalized[0])).to.be.false;
+    expect(isAbsoluteArray(parsePathString(simpleShapes.normalized[0]))).to.be.true;
+    expect(isRelativeArray(shapes.relative[7])).to.be.false;
+    // console.log(parsePathString(shapes.relative[7]))
+    expect(isRelativeArray(parsePathString(shapes.relative[7]))).to.be.true;
+    expect(isNormalizedArray(simpleShapes.normalized[0])).to.be.false;
+    expect(isNormalizedArray(parsePathString(simpleShapes.normalized[0]))).to.be.true;
+    expect(isCurveArray(simpleShapes.normalized[1])).to.be.false;
+    expect(isCurveArray(parsePathString(simpleShapes.normalized[1]))).to.be.true;
+
+  });
+
   it(`Can cover all remaining branches`, () => {
-    const { pathFactory, getPointAtLength, getTotalLength } = SVGPathCommander;
-    const path = pathFactory(simpleShapes.normalized[0] as string, undefined);
-    expect(path.length).to.be.above(0);
+    const { splitPath, pathToString, optimizePath, parsePathString, getPathBBox, getPointAtLength, getTotalLength } = SVGPathCommander;
+    expect(getPointAtLength(simpleShapes.normalized[3], 24.057395479452424)).to.deep.equal({ x: 14, y: 10 });
     expect(getPointAtLength(simpleShapes.normalized[0], 0)).to.deep.equal({ x: 10, y: 10 });
-    expect(getTotalLength(simpleShapes.normalized[0])).to.be.above(233); 
-    const cubic = getCubicProperties(16, 8, 16, 4.134, 12.418, 1, 8, 1, undefined);
-    expect(cubic.length).to.be.above(0);
-    const quad = getQuadProperties(8, 1.34, 10.75, 1.34, 12.7, 3.29, undefined);
-    expect(quad.length).to.be.above(0);
-    const arc = getArcProperties(10, 0, 0.5, 0.5, 0, 0, 1, 10, 1, undefined);
-    expect(arc.length).to.be.above(0);
+    expect(getPointAtLength(simpleShapes.normalized[3], undefined)).to.deep.equal({ x: 6, y: 10 });
+    expect(getTotalLength(simpleShapes.normalized[0])).to.be.above(233);
+    expect(getPathBBox(simpleShapes.normalized[2])).to.deep.equal({
+      "cx": 100, "cy": 50, "cz": 192.5,
+      "height": 25, "width": 180,
+      "x": 10, "y": 37.5, "x2": 190, "y2": 62.5,
+    });
+    expect(getPathBBox(simpleShapes.normalized[1])).to.deep.equal({
+      "cx": 90, "cy": 50, "cz": 200,
+      "height": 80, "width": 160,
+      "x": 10, "y": 10, "x2": 170,"y2": 90,
+    });
+    expect(splitPath(parsePathString(shapes.relative[1])).length).to.equal(7);
+    expect(pathToString(optimizePath(parsePathString(
+      // 'M10 50q15 -25 30 0Q55 75 70 50Q85 25 100 50T130 50Q145 25 160 50t30 0'
+      simpleShapes.normalized[2]
+    ), 2))).to.equal(simpleShapes.initial[2]);
+    // M10 50q15 -25 30 0t30 0t30 0t30 0t30 0t30 0
   });
 });

package/cypress.config.ts

@@ -1,29 +0,0 @@
-import { defineConfig } from "cypress";
-import createBundler from "@bahmutov/cypress-esbuild-preprocessor";
-import createEsbuildIstanbulPlugin from "./cypress/plugins/esbuild-istanbul";
-
-async function setupNodeEvents(
-  on: Cypress.PluginEvents,
-  config: Cypress.PluginConfigOptions
-): Promise<Cypress.PluginConfigOptions> {
-  await require("@cypress/code-coverage/task")(on, config);
-
-  on(
-    "file:preprocessor",
-    createBundler({
-      plugins: [createEsbuildIstanbulPlugin()],
-    })
-  );
-
-  // Make sure to return the config object as it might have been modified by the plugin.
-  return config;
-}
-
-export default defineConfig({
-  e2e: {
-    specPattern: "cypress/e2e/**/*.{js,jsx,ts,tsx}",
-    supportFile: "cypress/support/e2e.ts",
-    video: false,
-    setupNodeEvents,
-  },
-});

package/src/math/polygonArea.ts

@@ -1,27 +0,0 @@
-/**
- * d3-polygon-area
- * https://github.com/d3/d3-polygon
- *
- * Returns the area of a polygon.
- *
- * @param polygon an array of coordinates
- * @returns the polygon area
- */
-const polygonArea = (polygon: [number, number][]): number => {
-  const n = polygon.length;
-  let i = -1;
-  let a;
-  let b = polygon[n - 1];
-  let area = 0;
-
-  /* eslint-disable-next-line */
-  while (++i < n) {
-    a = b;
-    b = polygon[i];
-    area += a[1] * b[0] - a[0] * b[1];
-  }
-
-  return area / 2;
-};
-
-export default polygonArea;

package/src/math/polygonLength.ts

@@ -1,21 +0,0 @@
-import distanceSquareRoot from './distanceSquareRoot';
-
-/**
- * d3-polygon-length
- * https://github.com/d3/d3-polygon
- *
- * Returns the perimeter of a polygon.
- *
- * @param polygon an array of coordinates
- * @returns {number} the polygon length
- */
-const polygonLength = (polygon: [number, number][]): number => {
-  return polygon.reduce((length, point, i) => {
-    if (i) {
-      return length + distanceSquareRoot(polygon[i - 1], point);
-    }
-    return 0;
-  }, 0);
-};
-
-export default polygonLength;

package/src/process/fixArc.ts

@@ -1,23 +0,0 @@
-import { CSegment, PathArray, PathCommand } from '../types';
-
-/**
- * Splits an extended A (arc-to) segment into two cubic-bezier segments.
- *
- * @param path the `pathArray` this segment belongs to
- * @param allPathCommands all previous path commands
- * @param i the segment index
- */
-const fixArc = (path: PathArray, allPathCommands: PathCommand[], i: number) => {
-  if (path[i].length > 7) {
-    path[i].shift();
-    const segment = path[i];
-    let ni = i; // ESLint
-    while (segment.length) {
-      // if created multiple C:s, their original seg is saved
-      allPathCommands[i] = 'A';
-      path.splice((ni += 1), 0, ['C', ...segment.splice(0, 6)] as CSegment);
-    }
-    path.splice(i, 1);
-  }
-};
-export default fixArc;

package/src/process/replaceArc.ts

@@ -1,52 +0,0 @@
-import type { PathArray, PathCommand, PathSegment } from '../types';
-import isNormalizedArray from '../util/isNormalizedArray';
-import segmentToCubic from './segmentToCubic';
-import paramsParser from '../parser/paramsParser';
-import normalizePath from './normalizePath';
-import fixArc from './fixArc';
-import isAbsoluteArray from '../util/isAbsoluteArray';
-import pathToAbsolute from '../convert/pathToAbsolute';
-
-const replaceArc = (pathInput: PathArray | string): PathArray => {
-  const absolutePath = isAbsoluteArray(pathInput) ? pathInput : pathToAbsolute(pathInput);
-  const normalizedPath = isNormalizedArray(absolutePath) ? absolutePath : normalizePath(absolutePath);
-  const params = { ...paramsParser };
-  const allPathCommands = [] as PathCommand[]; // needed for arc to curve transformation
-  let segment = [] as unknown as PathSegment;
-  let seglen = 0;
-  let pathCommand = '';
-  const resultedPath = [] as unknown as PathArray;
-  let i = 0;
-  let ii = absolutePath.length;
-
-  for (i = 0; i < ii; i += 1) {
-    /* istanbul ignore else @preserve */
-    if (absolutePath[i]) [pathCommand] = absolutePath[i];
-    allPathCommands[i] = pathCommand as PathCommand;
-
-    /* istanbul ignore else @preserve */
-    if (pathCommand === 'A') {
-      segment = segmentToCubic(normalizedPath[i], params);
-
-      absolutePath[i] = segmentToCubic(normalizedPath[i], params);
-      fixArc(absolutePath, allPathCommands, i);
-
-      normalizedPath[i] = segmentToCubic(normalizedPath[i], params);
-      fixArc(normalizedPath, allPathCommands, i);
-      ii = Math.max(absolutePath.length, normalizedPath.length);
-    }
-
-    segment = normalizedPath[i];
-    seglen = segment.length;
-
-    params.x1 = +segment[seglen - 2];
-    params.y1 = +segment[seglen - 1];
-    params.x2 = +segment[seglen - 4] || params.x1;
-    params.y2 = +segment[seglen - 3] || params.y1;
-
-    resultedPath.push(absolutePath[i]);
-  }
-  return resultedPath;
-};
-
-export default replaceArc;

package/src/util/pathFactory.ts

@@ -1,130 +0,0 @@
-import type { MSegment, PathArray, PathSegment, Point } from '../types';
-// import type { LengthFactory } from '../interface';
-import normalizePath from '../process/normalizePath';
-import getLineSegmentProperties from '../math/lineTools';
-import getArcSegmentProperties from '../math/arcTools';
-import getCubicSegmentProperties from '../math/cubicTools';
-import getQuadSegmentProperties from '../math/quadTools';
-import DISTANCE_EPSILON from './distanceEpsilon';
-
-/**
- * Returns a {x,y} point at a given length
- * of a shape, the shape total length and
- * the shape minimum and maximum {x,y} coordinates.
- *
- * @param pathInput the `pathArray` to look into
- * @param distance the length of the shape to look at
- * @returns the path length, point, min & max
- */
-const pathFactory = (pathInput: string | PathArray, distance?: number) => {
-  const path = normalizePath(pathInput);
-  const distanceIsNumber = typeof distance === 'number';
-  let isM = false;
-  let data = [] as number[];
-  let pathCommand = 'M';
-  let x = 0;
-  let y = 0;
-  let mx = 0;
-  let my = 0;
-  let seg = path[0] as PathSegment;
-  const MIN = [] as Point[];
-  const MAX = [] as Point[];
-  let min = { x: 0, y: 0 };
-  let max = { x: 0, y: 0 };
-  let POINT = min;
-  let LENGTH = 0;
-  let props = {
-    point: { x: 0, y: 0 },
-    length: 0,
-    bbox: {
-      min: { x: 0, y: 0 },
-      max: { x: 0, y: 0 },
-    },
-  };
-
-  for (let i = 0, ll = path.length; i < ll; i += 1) {
-    seg = path[i];
-    [pathCommand] = seg;
-    isM = pathCommand === 'M';
-    data = !isM ? [x, y, ...(seg.slice(1) as number[])] : data;
-
-    if (distanceIsNumber && distance < DISTANCE_EPSILON) {
-      POINT = min;
-    }
-
-    // this segment is always ZERO
-    /* istanbul ignore else @preserve */
-    if (isM) {
-      // remember mx, my for Z
-      [, mx, my] = seg as MSegment;
-      min = { x: mx, y: my };
-      max = { x: mx, y: my };
-      props = {
-        point: min,
-        length: 0,
-        bbox: { min, max },
-      };
-    } else if (pathCommand === 'L') {
-      props = getLineSegmentProperties(
-        ...(data as [number, number, number, number]),
-        distanceIsNumber ? distance - LENGTH : undefined,
-      );
-    } else if (pathCommand === 'A') {
-      props = getArcSegmentProperties(
-        ...(data as [number, number, number, number, number, number, number, number, number]),
-        distanceIsNumber ? distance - LENGTH : undefined,
-      );
-    } else if (pathCommand === 'C') {
-      props = getCubicSegmentProperties(
-        ...(data as [number, number, number, number, number, number, number, number]),
-        distanceIsNumber ? distance - LENGTH : undefined,
-      );
-    } else if (pathCommand === 'Q') {
-      props = getQuadSegmentProperties(
-        ...(data as [number, number, number, number, number, number]),
-        distanceIsNumber ? distance - LENGTH : undefined,
-      );
-    } else if (pathCommand === 'Z') {
-      data = [x, y, mx, my];
-      props = getLineSegmentProperties(
-        ...(data as [number, number, number, number]),
-        distanceIsNumber ? distance - LENGTH : undefined,
-      );
-    }
-
-    if (distanceIsNumber && LENGTH < distance && LENGTH + props.length >= distance) {
-      POINT = props.point;
-    }
-
-    MIN.push(props.bbox.min);
-    MAX.push(props.bbox.max);
-    LENGTH += props.length;
-
-    [x, y] = pathCommand !== 'Z' ? (seg.slice(-2) as [number, number]) : [mx, my];
-  }
-
-  // native `getPointAtLength` behavior when the given distance
-  // is higher than total length
-  if (distanceIsNumber && distance > LENGTH - DISTANCE_EPSILON) {
-    POINT = { x, y };
-  }
-
-  return {
-    point: POINT,
-    length: LENGTH,
-    get bbox() {
-      return {
-        min: {
-          x: Math.min(...MIN.map(n => n.x)),
-          y: Math.min(...MIN.map(n => n.y)),
-        },
-        max: {
-          x: Math.max(...MAX.map(n => n.x)),
-          y: Math.max(...MAX.map(n => n.y)),
-        },
-      };
-    },
-  };
-};
-
-export default pathFactory;