freesewing/packages/cornelius/src/front.js

export default function (part) {
  let {
    options,
    Path,
    points,
    paths,
    Snippet,
    snippets,
    complete,
    sa,
    store,
    paperless,
    macro
  } = part.shorthand()

  const cc = 0.551915024494 // circle constant

  let halfInch = store.get('halfInch')
  let ventLength = store.get('ventLength')
  let waist = store.get('waist')
  let keystone = options.cuffStyle == 'keystone'

  let flyWidth = 3.5
  store.set('flyWidth', flyWidth)

  store.set('sideSeam', paths.sideSeam.length())

  points.pZcpR = points.pZ.shiftFractionTowards(points.pX, options.pctZtoR)
  points.pRcpZ = points.pR
    .shiftFractionTowards(points.pF, options.pctRtoZin)
    .shiftFractionTowards(points.pZ, options.pctRtoZup)

  let waistAngle = Math.abs(points.pW.angle(points.pD) - points.pW.angle(points.pZ))
  if (waistAngle > 180) {
    waistAngle -= 180
  }

  points.flyTop = points.pW.shift(
    points.pW.angle(points.pZ) - 180 + waistAngle,
    halfInch * flyWidth
  )
  points.flyBottom = points.flyTop.shift(
    points.pW.angle(points.pZ),
    points.pW.dist(points.pZ) - halfInch * flyWidth
  )

  points.pZcpFB = points.pZ.shift(points.pW.angle(points.pZ) - waistAngle, halfInch * flyWidth * cc)
  points.pFBcpZ = points.flyBottom.shift(points.pW.angle(points.pZ), halfInch * flyWidth * cc)

  paths.fly = new Path()
    .move(points.pW)
    .line(points.flyTop)
    .line(points.flyBottom)
    .curve(points.pFBcpZ, points.pZcpFB, points.pZ)
    .setRender(false)

  paths.flyFold = new Path().move(points.pW).line(points.pZ).attr('class', 'fabric dashed')

  store.set('frontWaistLength', paths.waistSeam.line(points.flyTop).length())

  paths.crotchSeam = new Path()
    .move(points.pZ)
    .curve(points.pZcpR, points.pRcpZ, points.pR)
    .setRender(false)

  points.pRcpK = points.pR
    .shiftFractionTowards(points.pF, options.pctRtoKin)
    .shiftFractionTowards(points.pK, options.pctRtoKdown)
  points.pKcpR = points.pK
    .shiftFractionTowards(points.pH, -1 * (options.pctKtoRout + options.fullness))
    .shiftFractionTowards(points.pR, options.pctKtoRup)

  paths.insideSeam = new Path()
    .move(points.pR)
    .curve(points.pRcpK, points.pKcpR, points.pK)
    .setRender(false)
  store.set('insideSeam', paths.insideSeam.length())

  let tempP = points.pH.shift(270, halfInch * 1.5)
  points.pKcpH = points.pK.shiftFractionTowards(tempP, options.pctKtoH)
  points.pJcpH = points.pJ.shiftFractionTowards(tempP, options.pctKtoH)

  paths.legSeam = new Path()
    .move(points.pK)
    .curve(points.pKcpH, points.pJcpH, points.pJ)
    .setRender(false)

  store.set('frontLegSeam', paths.legSeam.length())

  // Keystone original:
  // The keystone design has the slit in the cuff to the front. I deviated from
  // this for comfort and ease of construction preferences. The 'slit' is now
  // part of the side seam.
  if (keystone) {
    points.pSlitBottom = paths.legSeam.shiftAlong(paths.legSeam.length() - halfInch * 4)
    points.pSlitTop = points.pSlitBottom.shift(90, halfInch * 5 * options.ventLength)
    store.set('slitDistance', paths.legSeam.length() - halfInch * 4)
  }

  points.pocketWaist = paths.waistSeam.shiftAlong(waist / 2 / 4.5)
  points.pocketSide = paths.sideSeam.shiftAlong(paths.sideSeam.length() - (waist / 2 / 4.5) * 3.5)

  paths.pocketSeam = new Path().move(points.pocketSide).line(points.pocketWaist).setRender(false)

  paths.waistSeam = paths.waistSeam.split(points.pocketWaist)[1]
  paths.sideSeam = paths.sideSeam.split(points.pocketSide)[0]

  paths.seam = paths.waistSeam
    .join(paths.fly)
    .join(paths.crotchSeam)
    .join(paths.insideSeam)
    .join(paths.legSeam)
    .join(paths.sideSeam)
    .join(paths.pocketSeam)
    .close()
    .attr('class', 'fabric')

  points.topOfVent = paths.sideSeam.shiftAlong(ventLength)

  if (complete) {
    snippets.n1 = new Snippet('notch', points.pK)
    snippets.n2 = new Snippet('notch', points.pJ)
    snippets.n3 = new Snippet('notch', points.pocketWaist)
    snippets.n4 = new Snippet('notch', points.pocketSide)

    // Keystone original (see above):
    if (keystone) {
      paths.slit = new Path()
        .move(points.pSlitBottom)
        .line(points.pSlitTop)
        .attr('class', 'fabric')
        .attr('data-text', 'vent')
        .attr('data-text-class', 'text-xs center')
      snippets.n6 = new Snippet('notch', points.pSlitBottom)
    } else {
      tempP = paths.sideSeam.shiftAlong(ventLength)
      paths.vent = paths.sideSeam
        .split(tempP)[0]
        .attr('data-text', 'vent')
        .attr('data-text-class', 'text-xs center')
    }
    snippets.n5 = new Snippet('notch', points.topOfVent)

    points.logo = points.pE.clone()
    snippets.logo = new Snippet('logo', points.logo)
    points.title = points.logo.shift(270, 50)
    macro('title', {
      nr: 76,
      at: points.title,
      title: 'Front'
    })
    points.__titleNr.attr('data-text-class', 'center')
    points.__titleName.attr('data-text-class', 'center')
    points.__titlePattern.attr('data-text-class', 'center')

    points.scaleboxAnchor = points.pD.shift(270, 60)
    macro('scalebox', { at: points.scaleboxAnchor })

    macro('grainline', {
      from: points.pocketBL.shiftFractionTowards(points.pocketTL, -0.9),
      to: points.pocketTL
    })

    if (sa) {
      paths.sa = paths.seam.offset(sa).attr('class', 'fabric sa')
    }
  }

  // Paperless?
  if (paperless) {
    macro('ld', {
      from: points.topOfVent,
      to: points.pJ
    })
    macro('hd', {
      from: points.pocketSide,
      to: points.pocketWaist,
      y: points.pocketWaist.y + 15
    })
    macro('hd', {
      from: points.pW,
      to: points.pocketWaist,
      y: points.pocketWaist.y + 15
    })
    macro('hd', {
      from: points.pocketWaist,
      to: points.flyTop,
      y: points.pocketWaist.y + 15
    })
    macro('hd', {
      from: points.pAextra,
      to: points.pR
    })
    macro('hd', {
      from: points.pK,
      to: points.pJ,
      y: points.pJ.y - 15
    })
    // Keystone original (see above):
    if (keystone) {
      macro('hd', {
        from: points.pSlitBottom,
        to: points.pJ,
        y: points.pJ.y - 30
      })
      macro('vd', {
        from: points.pSlitTop,
        to: points.pSlitBottom,
        x: points.pSlitTop.x + 15
      })
    }
    macro('vd', {
      from: points.pocketSide,
      to: points.pocketWaist,
      x: points.pocketSide.x
    })
    macro('vd', {
      from: points.pW,
      to: points.pR,
      x: points.pR.x
    })
    macro('vd', {
      from: points.pR,
      to: points.pK,
      x: points.pR.x
    })
    macro('vd', {
      from: points.pW,
      to: points.pZ,
      x: points.pW.x + 15
    })
    macro('vd', {
      from: points.pJ,
      to: points.pocketWaist,
      x: points.pocketWaist.x
    })
  }

  return part
}