Function reversePath

src/lib/reverse-path.ts:10–104

(svg: SvgPath, subpathOfItem?: number)

export const reversePath = (svg: SvgPath, subpathOfItem?: number)=> {
  const {start, end} = getSubPathBounds(svg, subpathOfItem);

  if((end - start) <= 1) {
    return;
  }

  const isBeforeRelative = end < svg.path.length && svg.path[end].relative;
  if(isBeforeRelative) {
    svg.path[end].setRelative(false);
  }

  const subPath = svg.path.slice(start, end);
  const outputPath: SvgItem[] = [];
  const reversedPath = [...subPath].reverse().slice(0, -1);

  const startPoint = reversedPath[0].targetLocation();
  outputPath.push(SvgItem.Make(['M', ...toStr(startPoint)]));
  let previousType = '';
  let isClosed = false;

  for(const component of reversedPath) {
    const pt = toStr(component.previousPoint);
    const ctrl = component.absolutePoints.map(toStr);
    const type = component.getType(true);
    switch(type) {
      case 'M' :
      case 'Z' :
        if(isClosed) {
          outputPath.push(SvgItem.Make(['Z']));
        }
        isClosed = type === 'Z';
        if(outputPath[outputPath.length - 1].getType(true) === 'M') {
          outputPath[outputPath.length - 1] = SvgItem.Make(['M',  ...pt]);
        } else {
          outputPath.push(SvgItem.Make(['M',  ...pt]));
        }
        break;
      case 'L' :
        outputPath.push(SvgItem.Make(['L', ...pt]));
        break;
      case 'H' :
        outputPath.push(SvgItem.Make(['H', pt[0]]));
        break;
      case 'V' :
        outputPath.push(SvgItem.Make(['V', pt[1]]));
        break;
      case 'C' :
        outputPath.push(SvgItem.Make(['C', ...ctrl[1], ...ctrl[0], ...pt]));
        break;
      case 'S' : {
        const a = toStr(component.controlLocations()[0]);
        if(previousType !== 'S') {
          outputPath.push(SvgItem.Make(['C', ...ctrl[0], ...a, ...pt])); 
        } else {
          outputPath.push(SvgItem.Make(['S', ...a, ...pt]));
        }
        break;