1
0
Fork 0

chore(bee): Ported to v3

This commit is contained in:
Joost De Cock 2022-08-28 17:58:12 +02:00
parent 07175a7d00
commit 1bcdce2223
12 changed files with 820 additions and 922 deletions

View file

@ -14,7 +14,7 @@ const banner = `/**
const options = { const options = {
banner: { js: banner }, banner: { js: banner },
bundle: true, bundle: true,
entryPoints: ['src/index.js'], entryPoints: ['src/index.mjs'],
format: 'esm', format: 'esm',
outfile: 'dist/index.mjs', outfile: 'dist/index.mjs',
external: ["@freesewing"], external: ["@freesewing"],

View file

@ -1,154 +0,0 @@
import pkg from '../package.json' assert { type: 'json' }
import configHelpers from '@freesewing/config-helpers'
const { pctBasedOn } = configHelpers
const { version } = pkg
export default {
version,
name: 'bee',
design: 'PrudenceRabbit',
code: 'bobgeorgethe3rd',
department: 'tops',
type: 'pattern',
difficulty: 3,
optionGroups: {
fit: [
'chestEase',
'waistEase',
'bustSpanEase',
'topDepth',
'bottomCupDepth',
'sideDepth',
'sideCurve',
'frontCurve',
'bellaGuide',
],
style: [
'ties',
'neckTieWidth',
'neckTieLength',
'neckTieEnds',
'neckTieColours',
'bandTieWidth',
'bandTieLength',
'bandTieEnds',
'bandTieColours',
'crossBackTies',
'bandLength',
],
advanced: [
{ bellaDarts: ['backDartHeight'] },
{ bellaArmhole: ['armholeDepth', 'frontArmholePitchDepth'] },
{
bellaAdvanced: [
'frontShoulderWidth',
'fullChestEaseReduction',
'highBustWidth',
'shoulderToShoulderEase',
],
},
],
},
measurements: [
'highBust',
'chest',
'underbust',
'waist',
'waistBack',
'bustSpan',
'neck',
'hpsToBust',
'hpsToWaistFront',
'hpsToWaistBack',
'shoulderToShoulder',
'shoulderSlope',
'bustPointToUnderbust',
// FIXME: Measurement from waist up to armhole (for sleeveless)
],
dependencies: {
frontSideDart: 'back',
bandTie: 'cup',
cup: 'neckTie',
},
inject: { cup: 'frontSideDart' },
hide: ['frontSideDart', 'back'],
parts: [
'back',
'frontSideDart',
'cup',
'neckTie',
'bandTie',
// 'frontShoulderDart'
],
options: {
// Constants
acrossBackFactor: 0.925,
shoulderSlopeBack: 1.23,
neckWidthBack: 0.197,
neckWidthFront: 0.17,
backDartLocation: 0.145,
backCenterWaistReduction: 0.35,
collarFactor: 0.19,
backNeckCutout: 0.06,
backHemSlope: 2.5,
backArmholeSlant: 5,
backArmholeCurvature: 0.63,
frontArmholeCurvature: 0.63,
backArmholePitchDepth: 0.35,
bustDartLength: 1,
waistDartLength: 1,
bustDartCurve: 1,
// Percentages
//Bella Fit
waistEase: { pct: 5, min: 1, max: 20 },
chestEase: { pct: 11, min: 5, max: 20 },
bustSpanEase: { pct: 10, min: 0, max: 20 },
//Bella Advanced
shoulderToShoulderEase: { pct: -0.5, min: -1, max: 5 },
backDartHeight: { pct: 46, min: 38, max: 54 },
armholeDepth: { pct: 44, min: 38, max: 46 },
frontArmholePitchDepth: { pct: 29, max: 31, min: 27 },
frontShoulderWidth: { pct: 95, max: 98, min: 92 },
fullChestEaseReduction: { pct: 4, min: 0, max: 8 },
highBustWidth: { pct: 86, max: 92, min: 80 },
// Bikini Top
topDepth: { pct: 54, min: 50, max: 80 },
//neckTieWidth: { mm: 13, min: 6, max: 30},
neckTieWidth: {
pct: 6,
min: 2,
max: 18,
snap: {
metric: [6, 13, 19, 25, 32, 38],
imperial: [6.35, 12.7, 19.05, 25.4, 31.75, 38.1],
},
...pctBasedOn('bustSpan'),
},
neckTieLength: { pct: 80, min: 70, max: 100 },
neckTieEnds: { dflt: 'straight', list: ['straight', 'pointed'] },
neckTieColours: { dflt: 'one', list: ['one', 'two'] },
//bandTieWidth: { mm: 13, min: 6, max: 30 },
bandTieWidth: {
pct: 3,
min: 1,
max: 9,
snap: {
metric: [6, 13, 19, 25, 32, 38],
imperial: [6.35, 12.7, 19.05, 25.4, 31.75, 38.1],
},
toAbs: (pct, { measurements }) => measurements.hpsToWaistFront * pct,
},
bandTieLength: { pct: 35, min: 30, max: 50 },
bandTieEnds: { dflt: 'straight', list: ['straight', 'pointed'] },
bandTieColours: { dflt: 'one', list: ['one', 'two'] },
bottomCupDepth: { pct: 8, min: 0, max: 20 },
sideDepth: { pct: 20.6, min: 0, max: 30 },
sideCurve: { pct: 0, min: -50, max: 50 },
frontCurve: { pct: 0, min: -50, max: 50 },
bellaGuide: { bool: false },
ties: { bool: true },
crossBackTies: { bool: false },
bandLength: { pct: 85, min: 75, max: 90 },
},
}

View file

@ -38,7 +38,7 @@
"vbuild": "VERBOSE=1 node --experimental-json-modules build.mjs", "vbuild": "VERBOSE=1 node --experimental-json-modules build.mjs",
"lab": "cd ../../sites/lab && yarn start", "lab": "cd ../../sites/lab && yarn start",
"tips": "node ../../scripts/help.mjs", "tips": "node ../../scripts/help.mjs",
"prettier": "npx prettier --write 'src/*.js' 'config/*.js'", "prettier": "npx prettier --write 'src/*.mjs' 'tests/*.mjs'",
"testci": "npx mocha tests/*.test.mjs --reporter ../../tests/reporters/terse.js", "testci": "npx mocha tests/*.test.mjs --reporter ../../tests/reporters/terse.js",
"cibuild_step5": "node --experimental-json-modules build.mjs" "cibuild_step5": "node --experimental-json-modules build.mjs"
}, },

View file

@ -0,0 +1,206 @@
import { cup } from './cup.mjs'
export const bandTie = {
name: 'bee.bandTie',
after: cup,
options: {
bandTieWidth: {
pct: 3,
min: 1,
max: 9,
snap: {
metric: [6, 13, 19, 25, 32, 38],
imperial: [6.35, 12.7, 19.05, 25.4, 31.75, 38.1],
},
toAbs: (pct, { measurements }) => measurements.hpsToWaistFront * pct,
menu: 'style',
},
bandTieLength: { pct: 35, min: 30, max: 50, menu: 'style' },
bandTieEnds: { dflt: 'straight', list: ['straight', 'pointed'], menu: 'style' },
bandTieColours: { dflt: 'one', list: ['one', 'two'], menu: 'style' },
},
draft: part => {
const {
store,
sa,
Point,
points,
Path,
paths,
options,
complete,
paperless,
macro,
measurements,
snippets,
Snippet,
absoluteOptions,
} = part.shorthand()
// band tie
if (!options.ties) {
if (!options.crossBackTies) {
part.render = false
}
}
let bandTieLength
if (options.crossBackTies)
bandTieLength = (measurements.underbust * options.bandLength) / 2 + options.neckTieWidth * 2
else bandTieLength = (measurements.underbust + measurements.underbust * options.bandTieLength) / 2
let bandTieWidth
if (options.crossBackTies) bandTieWidth = absoluteOptions.bandTieWidth * 2
else bandTieWidth = absoluteOptions.bandTieWidth
points.topLeft = new Point(0, 0)
points.topRight = new Point(bandTieWidth * 2, points.topLeft.y)
points.bottomLeft = new Point(points.topLeft.x, bandTieLength)
points.bottomRight = new Point(points.topRight.x, bandTieLength)
if (!options.crossBackTies) {
switch (options.bandTieEnds) {
case 'straight':
points.topMiddle = new Point(bandTieWidth, points.topLeft.y)
break
case 'pointed':
points.topMiddle = new Point(bandTieWidth, points.topLeft.y - bandTieWidth)
}
} else points.topMiddle = new Point(bandTieWidth, points.topLeft.y)
points.bottomMiddle = new Point(points.topMiddle.x, bandTieLength)
switch (options.bandTieColours) {
case 'one':
paths.seam = new Path()
.move(points.bottomRight)
.line(points.topRight)
.line(points.topMiddle)
.line(points.topLeft)
.line(points.bottomLeft)
.close()
break
case 'two':
paths.seam = new Path()
.move(points.bottomMiddle)
.line(points.topMiddle)
.line(points.topLeft)
.line(points.bottomLeft)
.close()
}
if (complete) {
points.cofLeft = points.bottomLeft.shift(0, bandTieWidth * (1 / 8))
points.grainlineLeft = points.topLeft.translate(bandTieWidth * (1 / 8), bandTieLength * (3 / 4))
points.title = points.topLeft.translate(bandTieWidth * (1 / 8), bandTieLength * (1 / 4))
if (!options.crossBackTies) {
macro('title', {
at: points.title,
nr: 3,
title: 'band tie',
scale: 0.2,
})
} else
macro('title', {
at: points.title,
nr: 3,
title: 'band',
scale: 0.5,
})
switch (options.bandTieColours) {
case 'one':
points.cofRight = points.bottomLeft.shift(0, bandTieWidth * (15 / 8))
points.grainlineRight = points.grainlineLeft.shift(0, bandTieWidth * (14 / 8))
paths.foldline = new Path()
.move(points.topMiddle)
.line(points.bottomMiddle)
.attr('data-text', 'Fold-line')
.attr('data-text-class', 'center')
.attr('class', 'various')
break
case 'two':
points.cofRight = points.bottomLeft.shift(0, bandTieWidth * (7 / 8))
points.grainlineRight = points.grainlineLeft.shift(0, bandTieWidth * (7 / 8))
}
macro('grainline', {
from: points.grainlineLeft,
to: points.grainlineRight,
})
macro('cutonfold', {
from: points.cofLeft,
to: points.cofRight,
grainline: true,
})
if (options.crossBackTies) {
let gatherLength = store.get('gatherLength')
snippets.centreNotch = new Snippet('notch', points.bottomRight)
points.sideNotch = points.bottomRight.shift(90, gatherLength)
snippets.sideNotch = new Snippet('notch', points.sideNotch)
paths.casingFold = new Path()
.move(points.topLeft.shift(-90, options.neckTieWidth))
.line(points.topRight.shift(-90, options.neckTieWidth))
.attr('class', 'various')
.attr('data-text', 'Fold-line')
.attr('data-text-class', 'center')
}
if (sa) {
paths.sa = paths.seam.offset(sa).attr('class', 'fabric sa')
}
if (paperless) {
macro('vd', {
from: points.bottomLeft,
to: points.topLeft,
x: points.topLeft.x - sa - 20,
})
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
switch (options.bandTieColours) {
case 'one':
macro('hd', {
from: points.topLeft,
to: points.topRight,
y: points.topLeft.x - sa - 30,
})
break
case 'two':
}
if (!options.crossBackTies) {
switch (options.bandTieEnds) {
case 'straight':
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
break
case 'pointed':
macro('vd', {
from: points.topLeft,
to: points.topMiddle,
x: points.topLeft.x - sa - 20,
})
macro('vd', {
from: points.bottomLeft,
to: points.topMiddle,
x: points.topLeft.x - sa - 30,
})
}
} else
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
if (options.crossBackTies) {
macro('vd', {
from: points.sideNotch,
to: points.bottomRight,
x: points.topRight.x + sa + 20,
})
}
}
}
return part
}
}

View file

@ -1,183 +0,0 @@
export default function (part) {
let {
store,
sa,
Point,
points,
Path,
paths,
options,
complete,
paperless,
macro,
measurements,
snippets,
Snippet,
absoluteOptions,
} = part.shorthand()
// band tie
if (!options.ties) {
if (!options.crossBackTies) {
part.render = false
}
}
let bandTieLength
if (options.crossBackTies)
bandTieLength = (measurements.underbust * options.bandLength) / 2 + options.neckTieWidth * 2
else bandTieLength = (measurements.underbust + measurements.underbust * options.bandTieLength) / 2
let bandTieWidth
if (options.crossBackTies) bandTieWidth = absoluteOptions.bandTieWidth * 2
else bandTieWidth = absoluteOptions.bandTieWidth
points.topLeft = new Point(0, 0)
points.topRight = new Point(bandTieWidth * 2, points.topLeft.y)
points.bottomLeft = new Point(points.topLeft.x, bandTieLength)
points.bottomRight = new Point(points.topRight.x, bandTieLength)
if (!options.crossBackTies) {
switch (options.bandTieEnds) {
case 'straight':
points.topMiddle = new Point(bandTieWidth, points.topLeft.y)
break
case 'pointed':
points.topMiddle = new Point(bandTieWidth, points.topLeft.y - bandTieWidth)
}
} else points.topMiddle = new Point(bandTieWidth, points.topLeft.y)
points.bottomMiddle = new Point(points.topMiddle.x, bandTieLength)
switch (options.bandTieColours) {
case 'one':
paths.seam = new Path()
.move(points.bottomRight)
.line(points.topRight)
.line(points.topMiddle)
.line(points.topLeft)
.line(points.bottomLeft)
.close()
break
case 'two':
paths.seam = new Path()
.move(points.bottomMiddle)
.line(points.topMiddle)
.line(points.topLeft)
.line(points.bottomLeft)
.close()
}
if (complete) {
points.cofLeft = points.bottomLeft.shift(0, bandTieWidth * (1 / 8))
points.grainlineLeft = points.topLeft.translate(bandTieWidth * (1 / 8), bandTieLength * (3 / 4))
points.title = points.topLeft.translate(bandTieWidth * (1 / 8), bandTieLength * (1 / 4))
if (!options.crossBackTies) {
macro('title', {
at: points.title,
nr: 3,
title: 'band tie',
scale: 0.2,
})
} else
macro('title', {
at: points.title,
nr: 3,
title: 'band',
scale: 0.5,
})
switch (options.bandTieColours) {
case 'one':
points.cofRight = points.bottomLeft.shift(0, bandTieWidth * (15 / 8))
points.grainlineRight = points.grainlineLeft.shift(0, bandTieWidth * (14 / 8))
paths.foldline = new Path()
.move(points.topMiddle)
.line(points.bottomMiddle)
.attr('data-text', 'Fold-line')
.attr('data-text-class', 'center')
.attr('class', 'various')
break
case 'two':
points.cofRight = points.bottomLeft.shift(0, bandTieWidth * (7 / 8))
points.grainlineRight = points.grainlineLeft.shift(0, bandTieWidth * (7 / 8))
}
macro('grainline', {
from: points.grainlineLeft,
to: points.grainlineRight,
})
macro('cutonfold', {
from: points.cofLeft,
to: points.cofRight,
grainline: true,
})
if (options.crossBackTies) {
let gatherLength = store.get('gatherLength')
snippets.centreNotch = new Snippet('notch', points.bottomRight)
points.sideNotch = points.bottomRight.shift(90, gatherLength)
snippets.sideNotch = new Snippet('notch', points.sideNotch)
paths.casingFold = new Path()
.move(points.topLeft.shift(-90, options.neckTieWidth))
.line(points.topRight.shift(-90, options.neckTieWidth))
.attr('class', 'various')
.attr('data-text', 'Fold-line')
.attr('data-text-class', 'center')
}
if (sa) {
paths.sa = paths.seam.offset(sa).attr('class', 'fabric sa')
}
if (paperless) {
macro('vd', {
from: points.bottomLeft,
to: points.topLeft,
x: points.topLeft.x - sa - 20,
})
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
switch (options.bandTieColours) {
case 'one':
macro('hd', {
from: points.topLeft,
to: points.topRight,
y: points.topLeft.x - sa - 30,
})
break
case 'two':
}
if (!options.crossBackTies) {
switch (options.bandTieEnds) {
case 'straight':
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
break
case 'pointed':
macro('vd', {
from: points.topLeft,
to: points.topMiddle,
x: points.topLeft.x - sa - 20,
})
macro('vd', {
from: points.bottomLeft,
to: points.topMiddle,
x: points.topLeft.x - sa - 30,
})
}
} else
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
if (options.crossBackTies) {
macro('vd', {
from: points.sideNotch,
to: points.bottomRight,
x: points.topRight.x + sa + 20,
})
}
}
}
return part
}

View file

@ -1,379 +0,0 @@
export default function (part) {
let {
store,
sa,
Point,
points,
Path,
paths,
options,
complete,
paperless,
macro,
utils,
measurements,
snippets,
Snippet,
absoluteOptions,
} = part.shorthand()
//inherited from Bella
let angle = store.get('bustDartAngleSide')
//removing paths and snippets not required from Bella
for (let i in paths) delete paths[i]
for (let i in snippets) delete snippets[i]
//removing macros not required from Bella
macro('title', false)
macro('scalebox', false)
//bella alterations
points.sideHemNew = points.armhole.shiftOutwards(
points.bustDartTop,
points.bustDartBottom.dist(points.sideHemInitial)
)
points.waistDartRightRotated = points.waistDartRight.rotate(angle, points.bust)
if (options.bellaGuide) {
paths.bellaGuide = new Path()
.move(points.sideHemNew)
.line(points.bustDartTop)
.line(points.armhole)
.curve(points.armholeCp2, points.armholePitchCp1, points.armholePitch)
.curve_(points.armholePitchCp2, points.shoulder)
.line(points.hps)
.curve(points.hpsCp2, points.cfNeckCp1, points.cfNeck)
.line(points.cfHem)
.line(points.waistDartLeft)
.line(points.bustA)
.line(points.waistDartRightRotated)
.line(points.sideHemNew)
.attr('class', 'various lashed')
.close()
}
//bikini top
let underbust =
measurements.bustPointToUnderbust + measurements.bustPointToUnderbust * options.bottomCupDepth
points.top = points.bustA.shiftTowards(points.hps, measurements.hpsToBust * options.topDepth)
points.topLeft = points.top.shift(
points.top.angle(points.hps) + 90,
absoluteOptions.neckTieWidth / 2
)
points.topRight = points.top.shift(
points.top.angle(points.hps) - 90,
absoluteOptions.neckTieWidth / 2
)
points.leftDart = points.bustA.shiftTowards(points.waistDartLeft, underbust)
points.rightDart = points.bustA.shiftTowards(points.waistDartRightRotated, underbust)
points.lefti = utils.beamsIntersect(
points.leftDart,
points.leftDart.shift(points.leftDart.angle(points.bustA) + 90, 10),
points.cfNeck,
points.cfHem
)
points.righti = utils.beamsIntersect(
points.rightDart,
points.rightDart.shift(points.rightDart.angle(points.bustA) - 90, 10),
points.armhole,
points.sideHemNew
)
points.rightiOffset = points.righti.shiftFractionTowards(points.rightDart, options.sideDepth)
points.sideEdge = points.rightiOffset.shift(
points.armhole.angle(points.righti),
absoluteOptions.bandTieWidth
)
points.frontEdge = points.lefti.shift(
points.cfNeck.angle(points.cfHem),
absoluteOptions.bandTieWidth
)
points.middleDart = points.bustA.shift(
points.bustA.angle(points.leftDart) +
(points.bustA.angle(points.rightDart) - points.bustA.angle(points.leftDart)) / 2,
points.bustA.dist(points.leftDart)
)
points.casingDart = points.bustA.shiftOutwards(points.middleDart, absoluteOptions.bandTieWidth)
points.leftControli = utils.beamsIntersect(
points.casingDart,
points.casingDart.shift(points.bustA.angle(points.middleDart) - 90, 10),
points.cfNeck,
points.cfHem
)
points.rightControli = utils.beamsIntersect(
points.casingDart,
points.casingDart.shift(points.bustA.angle(points.middleDart) + 90, 10),
points.armhole,
points.sideHemNew
)
points.leftControl = points.casingDart.shiftFractionTowards(points.leftControli, 0.5)
points.rightControl = points.casingDart.shiftFractionTowards(points.rightControli, 0.5)
points.middleSideFront = points.rightiOffset.shiftFractionTowards(points.topRight, 0.5)
points.sideCurveControl = points.middleSideFront.shiftFractionTowards(
points.bustA,
options.sideCurve
)
points.middleFront = points.topLeft.shiftFractionTowards(points.lefti, 0.5)
points.frontCurveControl = points.middleFront.shiftFractionTowards(
points.bustA,
options.frontCurve
)
points.leftControlOffset = points.leftControl.shiftTowards(
points.top,
absoluteOptions.bandTieWidth
)
points.rightControlOffset = points.rightControl.shiftTowards(
points.top,
absoluteOptions.bandTieWidth
)
if (!options.crossBackTies) {
paths.seam = new Path()
.move(points.sideEdge)
.line(points.rightiOffset)
.curve_(points.sideCurveControl, points.topRight)
.line(points.topLeft)
.curve_(points.frontCurveControl, points.lefti)
.line(points.frontEdge)
.curve_(points.leftControl, points.casingDart)
.curve_(points.rightControl, points.sideEdge)
.close()
}
if (options.crossBackTies) {
paths.seam = new Path()
.move(points.rightiOffset)
.curve_(points.sideCurveControl, points.topRight)
.line(points.topLeft)
.curve_(points.frontCurveControl, points.lefti)
.curve_(points.leftControlOffset, points.middleDart)
.curve_(points.rightControlOffset, points.rightiOffset)
.close()
}
if (complete) {
points.grainlineTop = points.top.shiftFractionTowards(points.bustA, 0.05)
points.grainlineBottom = points.bustA.shiftFractionTowards(points.top, 0.05)
macro('grainline', {
from: points.grainlineTop,
to: points.grainlineBottom,
})
paths.frontCurve = new Path()
.move(points.topLeft)
.curve_(points.frontCurveControl, points.lefti)
.setRender(false)
points.frontNotch = paths.frontCurve.shiftFractionAlong(0.5)
snippets.frontNotch = new Snippet('notch', points.frontNotch)
snippets.lefti = new Snippet('notch', points.lefti)
snippets.righti = new Snippet('notch', points.rightiOffset)
if (!options.crossBackTies) {
snippets.frontEdge = new Snippet('notch', points.frontEdge)
snippets.sideEdge = new Snippet('notch', points.sideEdge)
}
points.title = points.grainlineBottom.shift(
points.bustA.angle(points.top) - 90,
points.grainlineTo.dist(points.grainlineBottom)
)
macro('title', {
at: points.title,
nr: 1,
title: 'cup',
scale: 0.7,
rotation: 90 - points.bustA.angle(points.top) - 270,
})
points.scalebox = new Point(points.lefti.x + 12.7, points.topLeft.y + 12.7)
macro('miniscale', { at: points.scalebox })
if (!options.crossBackTies) {
paths.casingline = new Path()
.move(points.lefti)
.curve_(points.leftControlOffset, points.middleDart)
.curve_(points.rightControlOffset, points.rightiOffset)
.attr('class', 'fabric lashed')
.attr('data-text', 'Casing Stitching Line')
.attr('data-text-class', 'center')
}
points.logo = points.grainlineTop.shiftOutwards(
points.grainlineBottom,
points.grainlineTo.dist(points.grainlineBottom) * 9
)
snippets.logo = new Snippet('logo', points.logo)
.attr('data-rotate', 90 - points.bustA.angle(points.top) - 270)
.attr('data-scale', 0.7)
if (!options.ties) {
let neckTieLength = utils.units(store.get('neckTieLength'))
points.neckTieLength = points.__miniscaleImperialBottomLeft
.shiftFractionTowards(points.lefti, 1 / 10)
.attr('data-text', 'Neck Tie Length: ')
.attr('data-text', neckTieLength)
if (!options.crossBackTies) {
let bandTieLength = utils.units(
measurements.underbust + measurements.underbust * options.bandTieLength
)
points.backTieLength = points.__miniscaleImperialBottomLeft
.shiftFractionTowards(points.lefti, 2 / 10)
.attr('data-text', 'Band Tie Length: ')
.attr('data-text', bandTieLength)
}
}
if (sa) {
paths.sa = paths.seam.offset(sa).attr('class', 'fabric sa')
}
if (paperless) {
if (!options.crossBackTies) {
macro('vd', {
from: points.frontEdge,
to: points.lefti,
x: points.frontEdge.x - sa - 20,
})
}
macro('vd', {
from: points.lefti,
to: points.topLeft,
x: points.frontEdge.x - sa - 20,
})
macro('vd', {
from: points.topLeft,
to: points.topRight,
x: points.frontEdge.x - sa - 20,
})
if (!options.crossBackTies) {
macro('vd', {
from: points.frontEdge,
to: points.topRight,
x: points.frontEdge.x - sa - 30,
})
}
macro('hd', {
from: points.topLeft,
to: points.topRight,
y: points.topRight.y - sa - 20,
})
macro('hd', {
from: points.lefti,
to: points.topLeft,
y: points.topRight.y - sa - 20,
})
macro('hd', {
from: points.topRight,
to: points.rightiOffset,
y: points.topRight.y - sa - 20,
})
if (!options.crossBackTies) {
macro('hd', {
from: points.rightiOffset,
to: points.sideEdge,
y: points.topRight.y - sa - 20,
})
}
macro('hd', {
from: points.frontEdge,
to: points.rightiOffset,
y: points.topRight.y - sa - 30,
})
if (!options.crossBackTies) {
macro('hd', {
from: points.frontEdge,
to: points.sideEdge,
y: points.topRight.y - sa - 40,
})
}
macro('vd', {
from: points.topRight,
to: points.rightiOffset,
x: points.sideEdge.x + sa + 20,
})
if (!options.crossBackTies) {
macro('vd', {
from: points.rightiOffset,
to: points.sideEdge,
x: points.sideEdge.x + sa + 20,
})
macro('vd', {
from: points.topRight,
to: points.sideEdge,
x: points.sideEdge.x + sa + 30,
})
macro('vd', {
from: points.sideEdge,
to: points.casingDart,
x: points.sideEdge.x + sa + 10,
})
macro('hd', {
from: points.sideEdge,
to: points.casingDart,
y: points.casingDart.y + sa + 20,
})
macro('hd', {
from: points.casingDart,
to: points.frontEdge,
y: points.casingDart.y + sa + 20,
})
macro('vd', {
from: points.casingDart,
to: points.frontEdge,
x: points.frontEdge.x - sa - 10,
})
macro('vd', {
from: points.casingDart,
to: points.topRight,
x: points.frontEdge.x - sa - 40,
})
}
if (options.crossBackTies) {
macro('vd', {
from: points.rightiOffset,
to: points.middleDart,
x: points.sideEdge.x + sa + 10,
})
macro('hd', {
from: points.rightiOffset,
to: points.middleDart,
y: points.casingDart.y + sa + 20,
})
macro('hd', {
from: points.middleDart,
to: points.lefti,
y: points.casingDart.y + sa + 20,
})
macro('vd', {
from: points.middleDart,
to: points.lefti,
x: points.frontEdge.x - sa - 10,
})
macro('vd', {
from: points.middleDart,
to: points.topRight,
x: points.frontEdge.x - sa - 30,
})
}
macro('ld', {
from: points.rightiOffset,
to: points.righti,
})
}
if (options.crossBackTies) {
paths.curve = new Path()
.move(points.lefti)
.curve_(points.leftControlOffset, points.middleDart)
.curve_(points.rightControlOffset, points.rightiOffset)
.setRender(false)
paths.dart = new Path()
.move(
points.bustA.shiftOutwards(points.leftDart, points.topRight.dist(points.rightiOffset))
)
.line(points.bustA)
.line(
points.bustA.shiftOutwards(points.rightDart, points.topRight.dist(points.rightiOffset))
)
.setRender(false)
for (let p of paths.curve.intersects(paths.dart)) {
points.rightDarti = points.bustA.shiftFractionTowards(p, 1)
}
for (let p of paths.curve.reverse().intersects(paths.dart)) {
points.leftDarti = points.bustA.shiftFractionTowards(p, 1)
}
let leftCurve = paths.curve.reverse().split(points.leftDarti)
for (let i in leftCurve) {
paths.leftCurve = leftCurve[i].setRender(false)
}
let rightCurve = paths.curve.split(points.rightDarti)
for (let i in rightCurve) {
paths.rightCurve = rightCurve[i].setRender(false)
}
store.set('gatherLength', paths.leftCurve.length() + paths.rightCurve.length())
}
}
return part
}

396
designs/bee/src/cup.mjs Normal file
View file

@ -0,0 +1,396 @@
import { frontSideDart } from '@freesewing/bella'
import { neckTie } from './neck-tie.mjs'
export const cup = {
name: 'bee.cup',
from: { ...frontSideDart, hidden: true },
after: neckTie,
options: {
topDepth: { pct: 54, min: 50, max: 80, menu: 'fit' },
bottomCupDepth: { pct: 8, min: 0, max: 20, menu: 'fit' },
sideDepth: { pct: 20.6, min: 0, max: 30, menu: 'fit' },
sideCurve: { pct: 0, min: -50, max: 50, menu: 'fit' },
frontCurve: { pct: 0, min: -50, max: 50, menu: 'fit' },
bellaGuide: { bool: false, menu: 'fit' },
},
draft: part => {
const {
store,
sa,
Point,
points,
Path,
paths,
options,
complete,
paperless,
macro,
utils,
measurements,
snippets,
Snippet,
absoluteOptions,
} = part.shorthand()
//inherited from Bella
let angle = store.get('bustDartAngleSide')
//removing paths and snippets not required from Bella
for (let i in paths) delete paths[i]
for (let i in snippets) delete snippets[i]
//removing macros not required from Bella
macro('title', false)
macro('scalebox', false)
//bella alterations
points.sideHemNew = points.armhole.shiftOutwards(
points.bustDartTop,
points.bustDartBottom.dist(points.sideHemInitial)
)
points.waistDartRightRotated = points.waistDartRight.rotate(angle, points.bust)
if (options.bellaGuide) {
paths.bellaGuide = new Path()
.move(points.sideHemNew)
.line(points.bustDartTop)
.line(points.armhole)
.curve(points.armholeCp2, points.armholePitchCp1, points.armholePitch)
.curve_(points.armholePitchCp2, points.shoulder)
.line(points.hps)
.curve(points.hpsCp2, points.cfNeckCp1, points.cfNeck)
.line(points.cfHem)
.line(points.waistDartLeft)
.line(points.bustA)
.line(points.waistDartRightRotated)
.line(points.sideHemNew)
.attr('class', 'various lashed')
.close()
}
//bikini top
let underbust =
measurements.bustPointToUnderbust + measurements.bustPointToUnderbust * options.bottomCupDepth
points.top = points.bustA.shiftTowards(points.hps, measurements.hpsToBust * options.topDepth)
points.topLeft = points.top.shift(
points.top.angle(points.hps) + 90,
absoluteOptions.neckTieWidth / 2
)
points.topRight = points.top.shift(
points.top.angle(points.hps) - 90,
absoluteOptions.neckTieWidth / 2
)
points.leftDart = points.bustA.shiftTowards(points.waistDartLeft, underbust)
points.rightDart = points.bustA.shiftTowards(points.waistDartRightRotated, underbust)
points.lefti = utils.beamsIntersect(
points.leftDart,
points.leftDart.shift(points.leftDart.angle(points.bustA) + 90, 10),
points.cfNeck,
points.cfHem
)
points.righti = utils.beamsIntersect(
points.rightDart,
points.rightDart.shift(points.rightDart.angle(points.bustA) - 90, 10),
points.armhole,
points.sideHemNew
)
points.rightiOffset = points.righti.shiftFractionTowards(points.rightDart, options.sideDepth)
points.sideEdge = points.rightiOffset.shift(
points.armhole.angle(points.righti),
absoluteOptions.bandTieWidth
)
points.frontEdge = points.lefti.shift(
points.cfNeck.angle(points.cfHem),
absoluteOptions.bandTieWidth
)
points.middleDart = points.bustA.shift(
points.bustA.angle(points.leftDart) +
(points.bustA.angle(points.rightDart) - points.bustA.angle(points.leftDart)) / 2,
points.bustA.dist(points.leftDart)
)
points.casingDart = points.bustA.shiftOutwards(points.middleDart, absoluteOptions.bandTieWidth)
points.leftControli = utils.beamsIntersect(
points.casingDart,
points.casingDart.shift(points.bustA.angle(points.middleDart) - 90, 10),
points.cfNeck,
points.cfHem
)
points.rightControli = utils.beamsIntersect(
points.casingDart,
points.casingDart.shift(points.bustA.angle(points.middleDart) + 90, 10),
points.armhole,
points.sideHemNew
)
points.leftControl = points.casingDart.shiftFractionTowards(points.leftControli, 0.5)
points.rightControl = points.casingDart.shiftFractionTowards(points.rightControli, 0.5)
points.middleSideFront = points.rightiOffset.shiftFractionTowards(points.topRight, 0.5)
points.sideCurveControl = points.middleSideFront.shiftFractionTowards(
points.bustA,
options.sideCurve
)
points.middleFront = points.topLeft.shiftFractionTowards(points.lefti, 0.5)
points.frontCurveControl = points.middleFront.shiftFractionTowards(
points.bustA,
options.frontCurve
)
points.leftControlOffset = points.leftControl.shiftTowards(
points.top,
absoluteOptions.bandTieWidth
)
points.rightControlOffset = points.rightControl.shiftTowards(
points.top,
absoluteOptions.bandTieWidth
)
if (!options.crossBackTies) {
paths.seam = new Path()
.move(points.sideEdge)
.line(points.rightiOffset)
.curve_(points.sideCurveControl, points.topRight)
.line(points.topLeft)
.curve_(points.frontCurveControl, points.lefti)
.line(points.frontEdge)
.curve_(points.leftControl, points.casingDart)
.curve_(points.rightControl, points.sideEdge)
.close()
}
if (options.crossBackTies) {
paths.seam = new Path()
.move(points.rightiOffset)
.curve_(points.sideCurveControl, points.topRight)
.line(points.topLeft)
.curve_(points.frontCurveControl, points.lefti)
.curve_(points.leftControlOffset, points.middleDart)
.curve_(points.rightControlOffset, points.rightiOffset)
.close()
}
if (complete) {
points.grainlineTop = points.top.shiftFractionTowards(points.bustA, 0.05)
points.grainlineBottom = points.bustA.shiftFractionTowards(points.top, 0.05)
macro('grainline', {
from: points.grainlineTop,
to: points.grainlineBottom,
})
paths.frontCurve = new Path()
.move(points.topLeft)
.curve_(points.frontCurveControl, points.lefti)
.setRender(false)
points.frontNotch = paths.frontCurve.shiftFractionAlong(0.5)
snippets.frontNotch = new Snippet('notch', points.frontNotch)
snippets.lefti = new Snippet('notch', points.lefti)
snippets.righti = new Snippet('notch', points.rightiOffset)
if (!options.crossBackTies) {
snippets.frontEdge = new Snippet('notch', points.frontEdge)
snippets.sideEdge = new Snippet('notch', points.sideEdge)
}
points.title = points.grainlineBottom.shift(
points.bustA.angle(points.top) - 90,
points.grainlineTo.dist(points.grainlineBottom)
)
macro('title', {
at: points.title,
nr: 1,
title: 'cup',
scale: 0.7,
rotation: 90 - points.bustA.angle(points.top) - 270,
})
points.scalebox = new Point(points.lefti.x + 12.7, points.topLeft.y + 12.7)
macro('miniscale', { at: points.scalebox })
if (!options.crossBackTies) {
paths.casingline = new Path()
.move(points.lefti)
.curve_(points.leftControlOffset, points.middleDart)
.curve_(points.rightControlOffset, points.rightiOffset)
.attr('class', 'fabric lashed')
.attr('data-text', 'Casing Stitching Line')
.attr('data-text-class', 'center')
}
points.logo = points.grainlineTop.shiftOutwards(
points.grainlineBottom,
points.grainlineTo.dist(points.grainlineBottom) * 9
)
snippets.logo = new Snippet('logo', points.logo)
.attr('data-rotate', 90 - points.bustA.angle(points.top) - 270)
.attr('data-scale', 0.7)
if (!options.ties) {
let neckTieLength = utils.units(store.get('neckTieLength'))
points.neckTieLength = points.__miniscaleImperialBottomLeft
.shiftFractionTowards(points.lefti, 1 / 10)
.attr('data-text', 'Neck Tie Length: ')
.attr('data-text', neckTieLength)
if (!options.crossBackTies) {
let bandTieLength = utils.units(
measurements.underbust + measurements.underbust * options.bandTieLength
)
points.backTieLength = points.__miniscaleImperialBottomLeft
.shiftFractionTowards(points.lefti, 2 / 10)
.attr('data-text', 'Band Tie Length: ')
.attr('data-text', bandTieLength)
}
}
if (sa) {
paths.sa = paths.seam.offset(sa).attr('class', 'fabric sa')
}
if (paperless) {
if (!options.crossBackTies) {
macro('vd', {
from: points.frontEdge,
to: points.lefti,
x: points.frontEdge.x - sa - 20,
})
}
macro('vd', {
from: points.lefti,
to: points.topLeft,
x: points.frontEdge.x - sa - 20,
})
macro('vd', {
from: points.topLeft,
to: points.topRight,
x: points.frontEdge.x - sa - 20,
})
if (!options.crossBackTies) {
macro('vd', {
from: points.frontEdge,
to: points.topRight,
x: points.frontEdge.x - sa - 30,
})
}
macro('hd', {
from: points.topLeft,
to: points.topRight,
y: points.topRight.y - sa - 20,
})
macro('hd', {
from: points.lefti,
to: points.topLeft,
y: points.topRight.y - sa - 20,
})
macro('hd', {
from: points.topRight,
to: points.rightiOffset,
y: points.topRight.y - sa - 20,
})
if (!options.crossBackTies) {
macro('hd', {
from: points.rightiOffset,
to: points.sideEdge,
y: points.topRight.y - sa - 20,
})
}
macro('hd', {
from: points.frontEdge,
to: points.rightiOffset,
y: points.topRight.y - sa - 30,
})
if (!options.crossBackTies) {
macro('hd', {
from: points.frontEdge,
to: points.sideEdge,
y: points.topRight.y - sa - 40,
})
}
macro('vd', {
from: points.topRight,
to: points.rightiOffset,
x: points.sideEdge.x + sa + 20,
})
if (!options.crossBackTies) {
macro('vd', {
from: points.rightiOffset,
to: points.sideEdge,
x: points.sideEdge.x + sa + 20,
})
macro('vd', {
from: points.topRight,
to: points.sideEdge,
x: points.sideEdge.x + sa + 30,
})
macro('vd', {
from: points.sideEdge,
to: points.casingDart,
x: points.sideEdge.x + sa + 10,
})
macro('hd', {
from: points.sideEdge,
to: points.casingDart,
y: points.casingDart.y + sa + 20,
})
macro('hd', {
from: points.casingDart,
to: points.frontEdge,
y: points.casingDart.y + sa + 20,
})
macro('vd', {
from: points.casingDart,
to: points.frontEdge,
x: points.frontEdge.x - sa - 10,
})
macro('vd', {
from: points.casingDart,
to: points.topRight,
x: points.frontEdge.x - sa - 40,
})
}
if (options.crossBackTies) {
macro('vd', {
from: points.rightiOffset,
to: points.middleDart,
x: points.sideEdge.x + sa + 10,
})
macro('hd', {
from: points.rightiOffset,
to: points.middleDart,
y: points.casingDart.y + sa + 20,
})
macro('hd', {
from: points.middleDart,
to: points.lefti,
y: points.casingDart.y + sa + 20,
})
macro('vd', {
from: points.middleDart,
to: points.lefti,
x: points.frontEdge.x - sa - 10,
})
macro('vd', {
from: points.middleDart,
to: points.topRight,
x: points.frontEdge.x - sa - 30,
})
}
macro('ld', {
from: points.rightiOffset,
to: points.righti,
})
}
if (options.crossBackTies) {
paths.curve = new Path()
.move(points.lefti)
.curve_(points.leftControlOffset, points.middleDart)
.curve_(points.rightControlOffset, points.rightiOffset)
.setRender(false)
paths.dart = new Path()
.move(
points.bustA.shiftOutwards(points.leftDart, points.topRight.dist(points.rightiOffset))
)
.line(points.bustA)
.line(
points.bustA.shiftOutwards(points.rightDart, points.topRight.dist(points.rightiOffset))
)
.setRender(false)
for (let p of paths.curve.intersects(paths.dart)) {
points.rightDarti = points.bustA.shiftFractionTowards(p, 1)
}
for (let p of paths.curve.reverse().intersects(paths.dart)) {
points.leftDarti = points.bustA.shiftFractionTowards(p, 1)
}
let leftCurve = paths.curve.reverse().split(points.leftDarti)
for (let i in leftCurve) {
paths.leftCurve = leftCurve[i].setRender(false)
}
let rightCurve = paths.curve.split(points.rightDarti)
for (let i in rightCurve) {
paths.rightCurve = rightCurve[i].setRender(false)
}
store.set('gatherLength', paths.leftCurve.length() + paths.rightCurve.length())
}
}
return part
}
}

View file

@ -1,29 +0,0 @@
import freesewing from '@freesewing/core'
import Bella from '@freesewing/bella'
import bundle from '@freesewing/plugin-bundle'
import config from '../config'
// Parts
import draftCup from './cup'
import draftNeckTie from './neckTie'
import draftBandTie from './bandTie'
//import draftFrontShoulderDart from './front-shoulder-dart'
// Create design
const Bee = new freesewing.Design(config, bundle)
// Attach draft methods to prototype
for (let m of ['draftBack', 'draftFrontSideDart']) {
Bee.prototype[m] = function (part) {
return new Bella(this.settings)[m](part)
}
}
Bee.prototype.draftCup = draftCup
Bee.prototype.draftNeckTie = draftNeckTie
Bee.prototype.draftBandTie = draftBandTie
//Bee.prototype.draftFrontShoulderDart = (part) => draftFrontShoulderDart(part)
// Named exports
export { config, Bee }
// Default export
export default Bee

16
designs/bee/src/index.mjs Normal file
View file

@ -0,0 +1,16 @@
import { Design } from '@freesewing/core'
import { name, version } from '../package.json'
import { pluginBundle } from '@freesewing/plugin-bundle'
import { cup } from './cup.mjs'
import { neckTie } from './neck-tie.mjs'
import { bandTie } from './band-tie.mjs'
const Bee = new Design({
name,
version,
parts: [ cup, neckTie, bandTie ],
plugins: pluginBundle,
})
export { cup, neckTie, bandTie, Bee }

View file

@ -0,0 +1,190 @@
import { pctBasedOn } from '@freesewing/core'
export const neckTie = {
name: 'bee.neckTie',
measurements: [ 'underbust', 'hpsToBust', 'hpsToWaistFront' ],
options: {
ties: { bool: true, menu: 'style' },
crossBackTies: { bool: false, menu: 'style' },
bandLength: { pct: 85, min: 75, max: 90, menu: 'style' },
neckTieLength: { pct: 80, min: 70, max: 100, menu: 'style' },
neckTieWidth: {
pct: 6,
min: 2,
max: 18,
snap: {
metric: [6, 13, 19, 25, 32, 38],
imperial: [6.35, 12.7, 19.05, 25.4, 31.75, 38.1],
},
menu: 'style',
...pctBasedOn('bustSpan'),
},
neckTieEnds: { dflt: 'straight', list: ['straight', 'pointed'], menu: 'style' },
neckTieColours: { dflt: 'one', list: ['one', 'two'], menu: 'style' },
},
draft: part => {
const {
store,
sa,
Point,
points,
Path,
paths,
options,
complete,
paperless,
macro,
measurements,
absoluteOptions,
} = part.shorthand()
// neck tie
if (!options.ties) {
part.render = false
}
let neckTieLength
if (options.crossBackTies)
neckTieLength =
(Math.sqrt(
Math.pow(measurements.hpsToWaistFront, 2) +
Math.pow(measurements.underbust - measurements.underbust * options.neckTieLength, 2)
) +
measurements.underbust -
measurements.underbust * options.bandLength +
measurements.underbust -
measurements.underbust * options.bandLength * options.neckTieLength) /
2
else neckTieLength = (measurements.hpsToBust + measurements.hpsToBust * options.neckTieLength) / 2
store.set('neckTieLength', neckTieLength * 2)
points.topLeft = new Point(0, 0)
points.topRight = new Point(absoluteOptions.neckTieWidth * 2, points.topLeft.y)
points.bottomLeft = new Point(points.topLeft.x, neckTieLength)
points.bottomRight = new Point(points.topRight.x, neckTieLength)
switch (options.neckTieEnds) {
case 'straight':
points.topMiddle = new Point(absoluteOptions.neckTieWidth, points.topLeft.y)
break
case 'pointed':
points.topMiddle = new Point(
absoluteOptions.neckTieWidth,
points.topLeft.y - absoluteOptions.neckTieWidth
)
}
points.bottomMiddle = new Point(points.topMiddle.x, neckTieLength)
switch (options.neckTieColours) {
case 'one':
paths.seam = new Path()
.move(points.bottomRight)
.line(points.topRight)
.line(points.topMiddle)
.line(points.topLeft)
.line(points.bottomLeft)
.close()
break
case 'two':
paths.seam = new Path()
.move(points.bottomMiddle)
.line(points.topMiddle)
.line(points.topLeft)
.line(points.bottomLeft)
.close()
}
if (complete) {
points.cofLeft = points.bottomLeft.shift(0, absoluteOptions.neckTieWidth * (1 / 8))
points.grainlineLeft = points.topLeft.translate(
absoluteOptions.neckTieWidth * (1 / 8),
neckTieLength * (3 / 4)
)
points.title = points.topLeft.translate(
absoluteOptions.neckTieWidth * (1 / 8),
neckTieLength * (1 / 4)
)
macro('title', {
at: points.title,
nr: 2,
title: 'neck tie',
scale: 0.2,
})
switch (options.neckTieColours) {
case 'one':
points.cofRight = points.bottomLeft.shift(0, absoluteOptions.neckTieWidth * (15 / 8))
points.grainlineRight = points.grainlineLeft.shift(
0,
absoluteOptions.neckTieWidth * (14 / 8)
)
paths.foldline = new Path()
.move(points.topMiddle)
.line(points.bottomMiddle)
.attr('data-text', 'Fold-line')
.attr('data-text-class', 'center')
.attr('class', 'various')
break
case 'two':
points.cofRight = points.bottomLeft.shift(0, absoluteOptions.neckTieWidth * (7 / 8))
points.grainlineRight = points.grainlineLeft.shift(
0,
absoluteOptions.neckTieWidth * (7 / 8)
)
}
macro('grainline', {
from: points.grainlineLeft,
to: points.grainlineRight,
})
macro('cutonfold', {
from: points.cofLeft,
to: points.cofRight,
grainline: true,
})
if (sa) {
paths.sa = paths.seam.offset(sa).attr('class', 'fabric sa')
}
if (paperless) {
macro('vd', {
from: points.bottomLeft,
to: points.topLeft,
x: points.topLeft.x - sa - 20,
})
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
switch (options.neckTieColours) {
case 'one':
macro('hd', {
from: points.topLeft,
to: points.topRight,
y: points.topLeft.x - sa - 30,
})
break
case 'two':
}
switch (options.neckTieEnds) {
case 'straight':
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
break
case 'pointed':
macro('vd', {
from: points.topLeft,
to: points.topMiddle,
x: points.topLeft.x - sa - 20,
})
macro('vd', {
from: points.bottomLeft,
to: points.topMiddle,
x: points.topLeft.x - sa - 30,
})
}
}
}
return part
}
}

View file

@ -1,164 +0,0 @@
export default function (part) {
let {
store,
sa,
Point,
points,
Path,
paths,
options,
complete,
paperless,
macro,
measurements,
absoluteOptions,
} = part.shorthand()
// neck tie
if (!options.ties) {
part.render = false
}
let neckTieLength
if (options.crossBackTies)
neckTieLength =
(Math.sqrt(
Math.pow(measurements.hpsToWaistFront, 2) +
Math.pow(measurements.underbust - measurements.underbust * options.neckTieLength, 2)
) +
measurements.underbust -
measurements.underbust * options.bandLength +
measurements.underbust -
measurements.underbust * options.bandLength * options.neckTieLength) /
2
else neckTieLength = (measurements.hpsToBust + measurements.hpsToBust * options.neckTieLength) / 2
store.set('neckTieLength', neckTieLength * 2)
points.topLeft = new Point(0, 0)
points.topRight = new Point(absoluteOptions.neckTieWidth * 2, points.topLeft.y)
points.bottomLeft = new Point(points.topLeft.x, neckTieLength)
points.bottomRight = new Point(points.topRight.x, neckTieLength)
switch (options.neckTieEnds) {
case 'straight':
points.topMiddle = new Point(absoluteOptions.neckTieWidth, points.topLeft.y)
break
case 'pointed':
points.topMiddle = new Point(
absoluteOptions.neckTieWidth,
points.topLeft.y - absoluteOptions.neckTieWidth
)
}
points.bottomMiddle = new Point(points.topMiddle.x, neckTieLength)
switch (options.neckTieColours) {
case 'one':
paths.seam = new Path()
.move(points.bottomRight)
.line(points.topRight)
.line(points.topMiddle)
.line(points.topLeft)
.line(points.bottomLeft)
.close()
break
case 'two':
paths.seam = new Path()
.move(points.bottomMiddle)
.line(points.topMiddle)
.line(points.topLeft)
.line(points.bottomLeft)
.close()
}
if (complete) {
points.cofLeft = points.bottomLeft.shift(0, absoluteOptions.neckTieWidth * (1 / 8))
points.grainlineLeft = points.topLeft.translate(
absoluteOptions.neckTieWidth * (1 / 8),
neckTieLength * (3 / 4)
)
points.title = points.topLeft.translate(
absoluteOptions.neckTieWidth * (1 / 8),
neckTieLength * (1 / 4)
)
macro('title', {
at: points.title,
nr: 2,
title: 'neck tie',
scale: 0.2,
})
switch (options.neckTieColours) {
case 'one':
points.cofRight = points.bottomLeft.shift(0, absoluteOptions.neckTieWidth * (15 / 8))
points.grainlineRight = points.grainlineLeft.shift(
0,
absoluteOptions.neckTieWidth * (14 / 8)
)
paths.foldline = new Path()
.move(points.topMiddle)
.line(points.bottomMiddle)
.attr('data-text', 'Fold-line')
.attr('data-text-class', 'center')
.attr('class', 'various')
break
case 'two':
points.cofRight = points.bottomLeft.shift(0, absoluteOptions.neckTieWidth * (7 / 8))
points.grainlineRight = points.grainlineLeft.shift(
0,
absoluteOptions.neckTieWidth * (7 / 8)
)
}
macro('grainline', {
from: points.grainlineLeft,
to: points.grainlineRight,
})
macro('cutonfold', {
from: points.cofLeft,
to: points.cofRight,
grainline: true,
})
if (sa) {
paths.sa = paths.seam.offset(sa).attr('class', 'fabric sa')
}
if (paperless) {
macro('vd', {
from: points.bottomLeft,
to: points.topLeft,
x: points.topLeft.x - sa - 20,
})
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
switch (options.neckTieColours) {
case 'one':
macro('hd', {
from: points.topLeft,
to: points.topRight,
y: points.topLeft.x - sa - 30,
})
break
case 'two':
}
switch (options.neckTieEnds) {
case 'straight':
macro('hd', {
from: points.topLeft,
to: points.topMiddle,
y: points.topLeft.x - sa - 20,
})
break
case 'pointed':
macro('vd', {
from: points.topLeft,
to: points.topMiddle,
x: points.topLeft.x - sa - 20,
})
macro('vd', {
from: points.bottomLeft,
to: points.topMiddle,
x: points.topLeft.x - sa - 30,
})
}
}
}
return part
}

View file

@ -1,17 +1,16 @@
// This file is auto-generated. // This file is auto-generated | Any changes you make will be overwritten.
// Changes you make will be overwritten. import { Bee } from './dist/index.mjs'
import Pattern from './dist/index.mjs'
// Shared tests // Shared tests
import { testPatternConfig } from '../../../tests/patterns/config.mjs' import { testPatternConfig } from '../../../tests/designs/config.mjs'
import { testPatternDrafting } from '../../../tests/patterns/drafting.mjs' import { testPatternDrafting } from '../../../tests/designs/drafting.mjs'
import { testPatternSampling } from '../../../tests/patterns/sampling.mjs' import { testPatternSampling } from '../../../tests/designs/sampling.mjs'
// Test config // Test config
testPatternConfig("bee", new Pattern()) testPatternConfig(Bee)
// Test drafting // Test drafting - Change the second parameter to `true` to log errors
testPatternDrafting("bee", Pattern) testPatternDrafting(Bee, true)
// Test sampling // Test sampling - Change the second parameter to `true` to log errors
testPatternSampling( "bee", Pattern) testPatternSampling(Bee, false)