2b254c721d
We started out with following dependencies that are injected (from) and now added dependencies that are merely required to be drafted first (after). This also adds further support for part-level configuration.
1026 lines
35 KiB
JavaScript
1026 lines
35 KiB
JavaScript
let expect = require("chai").expect;
|
|
let freesewing = require("../dist/index.js");
|
|
/*
|
|
it("Pattern constructor should initialize object", () => {
|
|
let pattern = new freesewing.Pattern({
|
|
foo: "bar",
|
|
options: {
|
|
constant: 2,
|
|
percentage: { pct: 30, min: 0, max: 100 }
|
|
}
|
|
});
|
|
expect(pattern.width).to.equal(0);
|
|
expect(pattern.height).to.equal(0);
|
|
expect(pattern.settings.complete).to.equal(true);
|
|
expect(pattern.parts).to.eql({});
|
|
expect(pattern.settings.units).to.equal("metric");
|
|
expect(pattern.config.foo).to.equal("bar");
|
|
expect(pattern.settings.options.constant).to.equal(2);
|
|
expect(pattern.settings.options.percentage).to.equal(0.3);
|
|
});
|
|
|
|
|
|
it("Should load percentage options", () => {
|
|
let pattern = new freesewing.Pattern({
|
|
options: {
|
|
test: { pct: 30 }
|
|
}
|
|
});
|
|
expect(pattern.settings.options.test).to.equal(0.3);
|
|
});
|
|
|
|
it("Should load millimeter options", () => {
|
|
let pattern = new freesewing.Pattern({
|
|
options: {
|
|
test: { mm: 30 }
|
|
}
|
|
});
|
|
expect(pattern.settings.options.test).to.equal(30);
|
|
});
|
|
|
|
it("Should load degree options", () => {
|
|
let pattern = new freesewing.Pattern({
|
|
options: {
|
|
test: { deg: 15 }
|
|
}
|
|
});
|
|
expect(pattern.settings.options.test).to.equal(15);
|
|
});
|
|
|
|
it("Should load an array option", () => {
|
|
let pattern = new freesewing.Pattern({
|
|
options: {
|
|
test: { dflt: "foo" }
|
|
}
|
|
});
|
|
expect(pattern.settings.options.test).to.equal("foo");
|
|
});
|
|
|
|
it("Should load a count option", () => {
|
|
let pattern = new freesewing.Pattern({
|
|
options: {
|
|
test: { count: 3 }
|
|
}
|
|
});
|
|
expect(pattern.settings.options.test).to.equal(3);
|
|
});
|
|
|
|
it("Should load a boolean option", () => {
|
|
let pattern = new freesewing.Pattern({
|
|
options: {
|
|
test1: { bool: false },
|
|
test2: { bool: true }
|
|
}
|
|
});
|
|
expect(pattern.settings.options.test1).to.be.false;
|
|
expect(pattern.settings.options.test2).to.be.true;
|
|
});
|
|
|
|
it("Should throw an error for an unknown option", () => {
|
|
expect(
|
|
() =>
|
|
new freesewing.Pattern({
|
|
options: {
|
|
test: { foo: "bar" }
|
|
}
|
|
})
|
|
).to.throw();
|
|
});
|
|
|
|
it("Should merge settings with default settings", () => {
|
|
let pattern = new freesewing.Pattern();
|
|
let settings = {
|
|
foo: "bar",
|
|
deep: {
|
|
free: "ze"
|
|
}
|
|
};
|
|
pattern.apply(settings);
|
|
expect(pattern.settings.foo).to.equal("bar");
|
|
expect(pattern.settings.locale).to.equal("en");
|
|
expect(pattern.settings.margin).to.equal(2);
|
|
expect(pattern.settings.idPrefix).to.equal("fs-");
|
|
expect(pattern.settings.deep.free).to.equal("ze");
|
|
});
|
|
|
|
it("Should draft according to settings", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
dependencies: { back: "front" },
|
|
inject: { back: "front" },
|
|
hide: ["back"]
|
|
});
|
|
Test.prototype.draftBack = function(part) {
|
|
this.count++;
|
|
return part;
|
|
};
|
|
Test.prototype.draftFront = function(part) {
|
|
this.count++;
|
|
return part;
|
|
};
|
|
|
|
let pattern = new Test();
|
|
pattern.count = 0;
|
|
pattern.draft();
|
|
expect(pattern.count).to.equal(2);
|
|
});
|
|
|
|
it("Should throw an error if per-part draft method is missing", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
dependencies: { back: "front" },
|
|
inject: { back: "front" },
|
|
hide: ["back"]
|
|
});
|
|
Test.prototype.draftBack = part => part;
|
|
let pattern = new Test();
|
|
expect(() => pattern.draft()).to.throw();
|
|
});
|
|
|
|
it("Should sample an option", () => {
|
|
let pattern = new freesewing.Pattern({
|
|
options: {
|
|
len: { pct: 30, min: 10 },
|
|
bonus: 10
|
|
}
|
|
});
|
|
pattern.draft = function() {
|
|
pattern.parts.a = new pattern.Part();
|
|
pattern.parts.b = new pattern.Part();
|
|
let a = pattern.parts.a;
|
|
a.points.from = new a.Point(0, 0);
|
|
a.points.to = new a.Point(
|
|
100 * a.context.settings.options.len,
|
|
a.context.settings.options.bonus
|
|
);
|
|
a.paths.test = new a.Path().move(a.points.from).line(a.points.to);
|
|
pattern.parts.b.inject(a);
|
|
};
|
|
pattern.settings.sample = {
|
|
type: "option",
|
|
option: "len"
|
|
};
|
|
pattern.sample();
|
|
expect(pattern.parts.a.paths.test_1.render).to.equal(true);
|
|
expect(pattern.parts.b.paths.test_10.ops[1].to.y).to.equal(10);
|
|
});
|
|
|
|
it("Should sample a list option", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
parts: ['front'],
|
|
options: {
|
|
len: {
|
|
dflt: 1,
|
|
list: [1,2,3]
|
|
}
|
|
},
|
|
})
|
|
Test.prototype.draftFront = function(part) {
|
|
const { Point, points, Path, paths, options } = part.shorthand()
|
|
points.from = new Point(0, 0);
|
|
points.to = new Point( 100 * options.len, 0)
|
|
paths.line = new Path()
|
|
.move(points.from)
|
|
.line(points.to)
|
|
|
|
return part
|
|
};
|
|
const pattern = new Test({
|
|
sample: {
|
|
type: 'option',
|
|
option: 'len'
|
|
}
|
|
})
|
|
pattern.sample();
|
|
expect(pattern.parts.front.paths.line_1.ops[1].to.x).to.equal(100);
|
|
expect(pattern.parts.front.paths.line_2.ops[1].to.x).to.equal(200);
|
|
expect(pattern.parts.front.paths.line_3.ops[1].to.x).to.equal(300);
|
|
});
|
|
|
|
it("Should sample a measurement", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
parts: ['front'],
|
|
measurements: ['head']
|
|
})
|
|
Test.prototype.draftFront = function(part) {
|
|
const { Point, points, Path, paths, measurements } = part.shorthand()
|
|
points.from = new Point(0, 0);
|
|
points.to = new Point( measurements.head, 0)
|
|
paths.line = new Path()
|
|
.move(points.from)
|
|
.line(points.to)
|
|
|
|
return part
|
|
};
|
|
const pattern = new Test({
|
|
measurements: {
|
|
head: 100
|
|
},
|
|
sample: {
|
|
type: 'measurement',
|
|
measurement: 'head'
|
|
}
|
|
})
|
|
pattern.sample();
|
|
expect(pattern.is).to.equal('sample')
|
|
expect(pattern.events.debug[0]).to.equal('Sampling measurement `head`')
|
|
for (let i=0;i<10;i++) {
|
|
const j = i + 1
|
|
expect(pattern.parts.front.paths[`line_${j}`].ops[1].to.x).to.equal(90 + 2*i);
|
|
}
|
|
pattern.sampleMeasurement('nope')
|
|
expect(pattern.events.error.length).to.equal(1)
|
|
expect(pattern.events.error[0]).to.equal("Cannot sample measurement `nope` because it's `undefined`")
|
|
});
|
|
|
|
it("Should sample models", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
parts: ['front'],
|
|
measurements: ['head']
|
|
})
|
|
Test.prototype.draftFront = function(part) {
|
|
const { Point, points, Path, paths, measurements } = part.shorthand()
|
|
points.from = new Point(0, 0);
|
|
points.to = new Point( measurements.head, 0)
|
|
paths.line = new Path()
|
|
.move(points.from)
|
|
.line(points.to)
|
|
|
|
return part
|
|
};
|
|
let pattern = new Test({
|
|
sample: {
|
|
type: 'models',
|
|
models : {
|
|
a: { head: 100 },
|
|
b: { head: 50 },
|
|
}
|
|
}
|
|
})
|
|
pattern.sample();
|
|
expect(pattern.is).to.equal('sample')
|
|
expect(pattern.events.debug[0]).to.equal('Sampling models')
|
|
expect(pattern.parts.front.paths[`line_0`].ops[1].to.x).to.equal(100);
|
|
expect(pattern.parts.front.paths[`line_1`].ops[1].to.x).to.equal(50);
|
|
pattern = new Test({
|
|
sample: {
|
|
type: 'models',
|
|
models : {
|
|
a: { head: 100 },
|
|
b: { head: 50 },
|
|
},
|
|
focus: 'b'
|
|
}
|
|
})
|
|
pattern.sample();
|
|
expect(pattern.is).to.equal('sample')
|
|
expect(pattern.parts.front.paths[`line_-1`].ops[1].to.x).to.equal(50);
|
|
expect(pattern.parts.front.paths[`line_0`].ops[1].to.x).to.equal(100);
|
|
});
|
|
|
|
it("Should register a hook via on", () => {
|
|
let pattern = new freesewing.Pattern();
|
|
let count = 0;
|
|
pattern._draft = () => {};
|
|
pattern.on("preDraft", function(pattern) {
|
|
count++;
|
|
});
|
|
pattern.draft();
|
|
expect(count).to.equal(1);
|
|
});
|
|
|
|
it("Should register a hook from a plugin", () => {
|
|
let pattern = new freesewing.Pattern();
|
|
let count = 0;
|
|
pattern._draft = () => {};
|
|
let plugin = {
|
|
name: "test",
|
|
version: "0.1-test",
|
|
hooks: {
|
|
preDraft: function(pattern) {
|
|
count++;
|
|
}
|
|
}
|
|
};
|
|
pattern.use(plugin);
|
|
pattern.draft();
|
|
expect(count).to.equal(1);
|
|
});
|
|
|
|
it("Should register multiple methods on a single hook", () => {
|
|
let pattern = new freesewing.Pattern();
|
|
let count = 0;
|
|
pattern._draft = () => {};
|
|
let plugin = {
|
|
name: "test",
|
|
version: "0.1-test",
|
|
hooks: {
|
|
preDraft: [
|
|
function(pattern) {
|
|
count++;
|
|
},
|
|
function(pattern) {
|
|
count++;
|
|
}
|
|
]
|
|
}
|
|
};
|
|
pattern.use(plugin);
|
|
pattern.draft();
|
|
expect(count).to.equal(2);
|
|
});
|
|
|
|
it("Should check whether a part is needed", () => {
|
|
let config = {
|
|
name: "test",
|
|
dependencies: { back: "front", side: "back" },
|
|
inject: { back: "front" },
|
|
hide: ["back"]
|
|
};
|
|
const Test = new freesewing.Design(config)
|
|
Test.prototype.draftBack = function(part) {
|
|
return part;
|
|
};
|
|
Test.prototype.draftFront = function(part) {
|
|
return part;
|
|
};
|
|
|
|
let pattern = new Test().init();
|
|
pattern.settings.only = "back";
|
|
//expect(pattern.needs("back")).to.equal(true);
|
|
expect(pattern.needs("front")).to.equal(true);
|
|
//expect(pattern.needs("side")).to.equal(false);
|
|
//pattern.settings.only = ["back", "side"];
|
|
//expect(pattern.needs("back")).to.equal(true);
|
|
//expect(pattern.needs("front")).to.equal(true);
|
|
//expect(pattern.needs("side")).to.equal(true);
|
|
});
|
|
|
|
it("Should check whether a part is wanted", () => {
|
|
let config = {
|
|
name: "test",
|
|
dependencies: { back: "front", side: "back" },
|
|
inject: { back: "front" },
|
|
hide: ["back"]
|
|
};
|
|
const Test = function(settings = false) {
|
|
freesewing.Pattern.call(this, config);
|
|
return this;
|
|
};
|
|
Test.prototype = Object.create(freesewing.Pattern.prototype);
|
|
Test.prototype.constructor = Test;
|
|
Test.prototype.draftBack = function(part) {
|
|
return part;
|
|
};
|
|
Test.prototype.draftFront = function(part) {
|
|
return part;
|
|
};
|
|
|
|
let pattern = new Test();
|
|
pattern.settings.only = "back";
|
|
expect(pattern.wants("back")).to.equal(true);
|
|
expect(pattern.wants("front")).to.equal(false);
|
|
expect(pattern.wants("side")).to.equal(false);
|
|
pattern.settings.only = ["back", "side"];
|
|
expect(pattern.wants("back")).to.equal(true);
|
|
expect(pattern.wants("front")).to.equal(false);
|
|
expect(pattern.wants("side")).to.equal(true);
|
|
});
|
|
|
|
it("Should correctly resolve dependencies - string version", () => {
|
|
let config = {
|
|
name: "test",
|
|
dependencies: { front: "back", side: "back", hood: "front", stripe: "hood" },
|
|
};
|
|
const Test = new freesewing.Design(config)
|
|
Test.prototype = Object.create(freesewing.Pattern.prototype);
|
|
Test.prototype.constructor = Test;
|
|
Test.prototype.draftBack = function(part) {
|
|
return part;
|
|
};
|
|
Test.prototype.draftFront = function(part) {
|
|
return part;
|
|
};
|
|
|
|
let pattern = new Test().init();
|
|
expect(pattern.config.resolvedDependencies.front.length).to.equal(1);
|
|
expect(pattern.config.resolvedDependencies.front[0]).to.equal('back');
|
|
expect(pattern.config.resolvedDependencies.side.length).to.equal(1);
|
|
expect(pattern.config.resolvedDependencies.side[0]).to.equal('back');
|
|
expect(pattern.config.resolvedDependencies.hood.length).to.equal(2);
|
|
expect(pattern.config.resolvedDependencies.hood[0]).to.equal('front');
|
|
expect(pattern.config.resolvedDependencies.hood[1]).to.equal('back');
|
|
expect(pattern.config.resolvedDependencies.stripe.length).to.equal(3);
|
|
expect(pattern.config.resolvedDependencies.stripe[0]).to.equal('hood');
|
|
expect(pattern.config.resolvedDependencies.stripe[1]).to.equal('front');
|
|
expect(pattern.config.resolvedDependencies.stripe[2]).to.equal('back');
|
|
expect(pattern.config.resolvedDependencies.back.length).to.equal(0);
|
|
expect(pattern.config.draftOrder[0]).to.equal('back');
|
|
expect(pattern.config.draftOrder[1]).to.equal('front');
|
|
expect(pattern.config.draftOrder[2]).to.equal('side');
|
|
expect(pattern.config.draftOrder[3]).to.equal('hood');
|
|
});
|
|
|
|
it("Should correctly resolve dependencies - array version", () => {
|
|
let config = {
|
|
name: "test",
|
|
dependencies: { front: ["back"], side: ["back"], hood: ["front"], stripe: ["hood"]},
|
|
};
|
|
const Test = function(settings = false) {
|
|
freesewing.Pattern.call(this, config);
|
|
return this;
|
|
};
|
|
Test.prototype = Object.create(freesewing.Pattern.prototype);
|
|
Test.prototype.constructor = Test;
|
|
Test.prototype.draftBack = function(part) {
|
|
return part;
|
|
};
|
|
Test.prototype.draftFront = function(part) {
|
|
return part;
|
|
};
|
|
|
|
let pattern = new Test().init();
|
|
expect(pattern.config.resolvedDependencies.front.length).to.equal(1);
|
|
expect(pattern.config.resolvedDependencies.front[0]).to.equal('back');
|
|
expect(pattern.config.resolvedDependencies.side.length).to.equal(1);
|
|
expect(pattern.config.resolvedDependencies.side[0]).to.equal('back');
|
|
expect(pattern.config.resolvedDependencies.hood.length).to.equal(2);
|
|
expect(pattern.config.resolvedDependencies.hood[0]).to.equal('front');
|
|
expect(pattern.config.resolvedDependencies.hood[1]).to.equal('back');
|
|
expect(pattern.config.resolvedDependencies.stripe.length).to.equal(3);
|
|
expect(pattern.config.resolvedDependencies.stripe[0]).to.equal('hood');
|
|
expect(pattern.config.resolvedDependencies.stripe[1]).to.equal('front');
|
|
expect(pattern.config.resolvedDependencies.stripe[2]).to.equal('back');
|
|
expect(pattern.config.resolvedDependencies.back.length).to.equal(0);
|
|
expect(pattern.config.draftOrder[0]).to.equal('back');
|
|
expect(pattern.config.draftOrder[1]).to.equal('front');
|
|
expect(pattern.config.draftOrder[2]).to.equal('side');
|
|
expect(pattern.config.draftOrder[3]).to.equal('hood');
|
|
});
|
|
|
|
it("Should correctly resolve dependencies - issue #971 - working version", () => {
|
|
let config = {
|
|
name: "test",
|
|
dependencies: {front:['back'],crotch:['front','back']},
|
|
parts: ['back','front','crotch'],
|
|
};
|
|
const Test = function(settings = false) {
|
|
freesewing.Pattern.call(this, config);
|
|
return this;
|
|
};
|
|
Test.prototype = Object.create(freesewing.Pattern.prototype);
|
|
Test.prototype.constructor = Test;
|
|
Test.prototype.draftBack = function(part) {
|
|
return part;
|
|
};
|
|
Test.prototype.draftFront = function(part) {
|
|
return part;
|
|
};
|
|
|
|
let pattern = new Test().init();
|
|
expect(pattern.config.draftOrder[0]).to.equal('back');
|
|
expect(pattern.config.draftOrder[1]).to.equal('front');
|
|
expect(pattern.config.draftOrder[2]).to.equal('crotch');
|
|
});
|
|
|
|
it("Should correctly resolve dependencies - issue #971 - broken version", () => {
|
|
let config = {
|
|
name: "test",
|
|
dependencies: {front:'back',crotch:['front','back']},
|
|
parts: ['back','front','crotch'],
|
|
};
|
|
const Test = function(settings = false) {
|
|
freesewing.Pattern.call(this, config);
|
|
return this;
|
|
};
|
|
Test.prototype = Object.create(freesewing.Pattern.prototype);
|
|
Test.prototype.constructor = Test;
|
|
Test.prototype.draftBack = function(part) {
|
|
return part;
|
|
};
|
|
Test.prototype.draftFront = function(part) {
|
|
return part;
|
|
};
|
|
|
|
let pattern = new Test().init();
|
|
expect(pattern.config.draftOrder[0]).to.equal('back');
|
|
expect(pattern.config.draftOrder[1]).to.equal('front');
|
|
expect(pattern.config.draftOrder[2]).to.equal('crotch');
|
|
});
|
|
|
|
it("Should correctly resolve dependencies - Handle uncovered code path", () => {
|
|
let config = {
|
|
name: "test",
|
|
dependencies: {
|
|
front: 'side',
|
|
crotch:['front','back'],
|
|
back: 1,
|
|
},
|
|
inject: {
|
|
front: 'back',
|
|
},
|
|
parts: ['back','front','crotch'],
|
|
};
|
|
const Test = function(settings = false) {
|
|
freesewing.Pattern.call(this, config);
|
|
return this;
|
|
};
|
|
Test.prototype = Object.create(freesewing.Pattern.prototype);
|
|
Test.prototype.constructor = Test;
|
|
Test.prototype.draftBack = function(part) {
|
|
return part;
|
|
};
|
|
Test.prototype.draftFront = function(part) {
|
|
return part;
|
|
};
|
|
|
|
let pattern = new Test().init();
|
|
const deps = pattern.resolveDependencies()
|
|
expect(pattern.config.draftOrder[0]).to.equal('side');
|
|
expect(pattern.config.draftOrder[1]).to.equal('back');
|
|
expect(pattern.config.draftOrder[2]).to.equal('front');
|
|
});
|
|
|
|
it("Should check whether created parts get the pattern context", () => {
|
|
let pattern = new freesewing.Pattern();
|
|
let part = new pattern.Part();
|
|
expect(part.context.settings).to.equal(pattern.settings);
|
|
});
|
|
|
|
it("Should correctly merge settings", () => {
|
|
let pattern = new freesewing.Pattern();
|
|
let settings = {
|
|
complete: false,
|
|
only: [1, 2, 3],
|
|
margin: 5
|
|
};
|
|
pattern.apply(settings);
|
|
expect(pattern.settings.complete).to.equal(false);
|
|
expect(pattern.settings.only[1]).to.equal(2);
|
|
expect(pattern.settings.margin).to.equal(5);
|
|
expect(pattern.settings.only.length).to.equal(3);
|
|
});
|
|
|
|
it("Should correctly merge settings for existing array", () => {
|
|
let pattern = new freesewing.Pattern();
|
|
pattern.settings.only = [1];
|
|
let settings = {
|
|
complete: false,
|
|
only: [2, 3, 4],
|
|
margin: 5
|
|
};
|
|
pattern.apply(settings);
|
|
expect(pattern.settings.complete).to.equal(false);
|
|
expect(pattern.settings.only.length).to.equal(4);
|
|
expect(pattern.settings.margin).to.equal(5);
|
|
});
|
|
|
|
it("Should return all render props", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
parts: ['front'],
|
|
});
|
|
Test.prototype.draftFront = function(part) {
|
|
return part;
|
|
};
|
|
const pattern = new Test()
|
|
pattern.draft();
|
|
const rp = pattern.getRenderProps()
|
|
expect(rp.svg.body).to.equal('');
|
|
expect(rp.width).to.equal(4);
|
|
expect(rp.height).to.equal(4);
|
|
expect(rp.parts.front.height).to.equal(4);
|
|
});
|
|
|
|
it("Should not pack a pattern with errors", () => {
|
|
const pattern = new freesewing.Pattern()
|
|
pattern.events.error.push('error')
|
|
pattern.pack()
|
|
expect(pattern.events.warning.length).to.equal(1)
|
|
expect(pattern.events.warning[0]).to.equal('One or more errors occured. Not packing pattern parts')
|
|
});
|
|
|
|
it("Should handle custom layouts", () => {
|
|
const Test = new freesewing.Design({ name: "test", parts: ['front'] })
|
|
Test.prototype.draftFront = function(part) { return part }
|
|
const pattern = new Test({
|
|
layout: {
|
|
width: 400,
|
|
height: 200,
|
|
parts: { front: { move: { x: 14, y: -202 } } }
|
|
}
|
|
})
|
|
pattern.pack()
|
|
expect(pattern.width).to.equal(400)
|
|
expect(pattern.height).to.equal(200)
|
|
});
|
|
|
|
it("Should handle a simple snapped option", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
parts: ['front'],
|
|
measurements: [ 'head' ],
|
|
options: {
|
|
len: { pct: 50, min: 22, max: 78, snap: 10, ...freesewing.pctBasedOn('head') }
|
|
}
|
|
})
|
|
Test.prototype.draftFront = function(part) {
|
|
const { Point, points, Path, paths, absoluteOptions } = part.shorthand()
|
|
points.from = new Point(0, 0);
|
|
points.to = new Point( 2 * absoluteOptions.len, 0)
|
|
paths.line = new Path()
|
|
.move(points.from)
|
|
.line(points.to)
|
|
|
|
return part
|
|
};
|
|
let pattern = new Test({
|
|
sample: {
|
|
type: 'option',
|
|
option: 'len'
|
|
},
|
|
measurements: {
|
|
head: 43.23
|
|
}
|
|
})
|
|
pattern.sample();
|
|
expect(pattern.is).to.equal('sample')
|
|
expect(pattern.events.debug[0]).to.equal('Sampling option `len`')
|
|
expect(pattern.parts.front.paths.line_1.ops[1].to.x).to.equal(20);
|
|
expect(pattern.parts.front.paths.line_2.ops[1].to.x).to.equal(40);
|
|
expect(pattern.parts.front.paths.line_3.ops[1].to.x).to.equal(40);
|
|
expect(pattern.parts.front.paths.line_4.ops[1].to.x).to.equal(40);
|
|
expect(pattern.parts.front.paths.line_5.ops[1].to.x).to.equal(60);
|
|
expect(pattern.parts.front.paths.line_6.ops[1].to.x).to.equal(60);
|
|
expect(pattern.parts.front.paths.line_7.ops[1].to.x).to.equal(60);
|
|
expect(pattern.parts.front.paths.line_8.ops[1].to.x).to.equal(60);
|
|
expect(pattern.parts.front.paths.line_9.ops[1].to.x).to.equal(80);
|
|
expect(pattern.parts.front.paths.line_10.ops[1].to.x).to.equal(80);
|
|
});
|
|
|
|
it("Should handle a list snapped option", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
parts: ['front'],
|
|
measurements: [ 'head' ],
|
|
options: {
|
|
len: { pct: 50, min: 22, max: 78, snap: [10,14,19,28], ...freesewing.pctBasedOn('head') }
|
|
}
|
|
})
|
|
Test.prototype.draftFront = function(part) {
|
|
const { Point, points, Path, paths, absoluteOptions } = part.shorthand()
|
|
points.from = new Point(0, 0);
|
|
points.to = new Point( absoluteOptions.len, 0)
|
|
paths.line = new Path()
|
|
.move(points.from)
|
|
.line(points.to)
|
|
|
|
return part
|
|
};
|
|
let pattern = new Test({
|
|
sample: {
|
|
type: 'option',
|
|
option: 'len'
|
|
},
|
|
measurements: {
|
|
head: 43.23
|
|
}
|
|
})
|
|
pattern.sample();
|
|
expect(pattern.is).to.equal('sample')
|
|
expect(pattern.events.debug[0]).to.equal('Sampling option `len`')
|
|
expect(pattern.parts.front.paths.line_1.ops[1].to.x).to.equal(10);
|
|
expect(pattern.parts.front.paths.line_2.ops[1].to.x).to.equal(14);
|
|
expect(pattern.parts.front.paths.line_3.ops[1].to.x).to.equal(14);
|
|
expect(pattern.parts.front.paths.line_4.ops[1].to.x).to.equal(19);
|
|
expect(pattern.parts.front.paths.line_5.ops[1].to.x).to.equal(19);
|
|
expect(pattern.parts.front.paths.line_6.ops[1].to.x).to.equal(19);
|
|
expect(pattern.parts.front.paths.line_7.ops[1].to.x).to.equal(28);
|
|
expect(pattern.parts.front.paths.line_8.ops[1].to.x).to.equal(28);
|
|
expect(pattern.parts.front.paths.line_9.ops[1].to.x).to.equal(28);
|
|
expect(freesewing.utils.round(pattern.parts.front.paths.line_10.ops[1].to.x)).to.equal(33.72);
|
|
});
|
|
|
|
|
|
it("Should retrieve the cutList", () => {
|
|
const Test = new freesewing.Design({
|
|
name: "test",
|
|
parts: ['front'],
|
|
})
|
|
Test.prototype.draftFront = function(part) {
|
|
part.addCut(4, 'lining', true)
|
|
|
|
return part
|
|
};
|
|
const pattern = new Test()
|
|
expect(JSON.stringify(pattern.getCutList())).to.equal(JSON.stringify({}))
|
|
pattern.draft()
|
|
const list = `{"front":{"grain":90,"materials":{"lining":{"cut":4,"identical":true}}}}`
|
|
expect(JSON.stringify(pattern.getCutList())).to.equal(list)
|
|
});
|
|
|
|
// 2022 style part inheritance
|
|
// I am aware this does too much for one unit test, but this is to simplify TDD
|
|
// we can split it up later
|
|
it("Design constructor should resolve nested injections (2022)", () => {
|
|
const partA = {
|
|
name: "partA",
|
|
options: { optionA: { bool: true } },
|
|
measurements: [ 'measieA' ],
|
|
optionalMeasurements: [ 'optmeasieA' ],
|
|
draft: part => {
|
|
const { points, Point, paths, Path } = part.shorthand()
|
|
points.a1 = new Point(1,1)
|
|
points.a2 = new Point(11,11)
|
|
paths.a = new Path().move(points.a1).line(points.a2)
|
|
return part
|
|
}
|
|
}
|
|
const partB = {
|
|
name: "partB",
|
|
from: partA,
|
|
options: { optionB: { pct: 12, min: 2, max: 20 } },
|
|
measurements: [ 'measieB' ],
|
|
optionalMeasurements: [ 'optmeasieB', 'measieA' ],
|
|
draft: part => {
|
|
const { points, Point, paths, Path } = part.shorthand()
|
|
points.b1 = new Point(2,2)
|
|
points.b2 = new Point(22,22)
|
|
paths.b = new Path().move(points.b1).line(points.b2)
|
|
return part
|
|
}
|
|
}
|
|
const partC = {
|
|
name: "partC",
|
|
from: partB,
|
|
options: { optionC: { deg: 5, min: 0, max: 15 } },
|
|
measurements: [ 'measieC' ],
|
|
optionalMeasurements: [ 'optmeasieC', 'measieA' ],
|
|
draft: part => {
|
|
const { points, Point, paths, Path } = part.shorthand()
|
|
points.c1 = new Point(3,3)
|
|
points.c2 = new Point(33,33)
|
|
paths.c = new Path().move(points.c1).line(points.c2)
|
|
return part
|
|
}
|
|
}
|
|
const partR = { // R for runtime, which is when this wil be attached
|
|
name: "partR",
|
|
from: partA,
|
|
after: partC,
|
|
options: { optionR: { dflt: 'red', list: ['red', 'green', 'blue'] } },
|
|
measurements: [ 'measieR' ],
|
|
optionalMeasurements: [ 'optmeasieR', 'measieA' ],
|
|
draft: part => {
|
|
const { points, Point, paths, Path } = part.shorthand()
|
|
points.r1 = new Point(4,4)
|
|
points.r2 = new Point(44,44)
|
|
paths.r = new Path().move(points.r1).line(points.r2)
|
|
return part
|
|
}
|
|
}
|
|
|
|
const Design = new freesewing.Design({ parts: { partC } });
|
|
const pattern = new Design().addPart(partR).draft()
|
|
// Measurements
|
|
expect(pattern.config.measurements.length).to.equal(4)
|
|
expect(pattern.config.measurements.indexOf('measieA') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieB') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieC') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieR') === -1).to.equal(false)
|
|
// Optional measurements
|
|
expect(pattern.config.optionalMeasurements.length).to.equal(4)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieA') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieB') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieC') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieR') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('measieA') === -1).to.equal(true)
|
|
// Options
|
|
expect(pattern.config.options.optionA.bool).to.equal(true)
|
|
expect(pattern.config.options.optionB.pct).to.equal(12)
|
|
expect(pattern.config.options.optionB.min).to.equal(2)
|
|
expect(pattern.config.options.optionB.max).to.equal(20)
|
|
expect(pattern.config.options.optionC.deg).to.equal(5)
|
|
expect(pattern.config.options.optionC.min).to.equal(0)
|
|
expect(pattern.config.options.optionC.max).to.equal(15)
|
|
expect(pattern.config.options.optionR.dflt).to.equal('red')
|
|
expect(pattern.config.options.optionR.list[0]).to.equal('red')
|
|
expect(pattern.config.options.optionR.list[1]).to.equal('green')
|
|
expect(pattern.config.options.optionR.list[2]).to.equal('blue')
|
|
// Dependencies
|
|
expect(pattern.config.dependencies.partB[0]).to.equal('partA')
|
|
expect(pattern.config.dependencies.partC[0]).to.equal('partB')
|
|
expect(pattern.config.dependencies.partR[0]).to.equal('partC')
|
|
expect(pattern.config.dependencies.partR[1]).to.equal('partA')
|
|
// Inject
|
|
expect(pattern.config.inject.partB).to.equal('partA')
|
|
expect(pattern.config.inject.partC).to.equal('partB')
|
|
expect(pattern.config.inject.partR).to.equal('partA')
|
|
// Draft order
|
|
expect(pattern.config.draftOrder[0]).to.equal('partA')
|
|
expect(pattern.config.draftOrder[1]).to.equal('partB')
|
|
expect(pattern.config.draftOrder[2]).to.equal('partC')
|
|
expect(pattern.config.draftOrder[3]).to.equal('partR')
|
|
// Points
|
|
expect(pattern.parts.partA.points.a1.x).to.equal(1)
|
|
expect(pattern.parts.partA.points.a1.y).to.equal(1)
|
|
expect(pattern.parts.partA.points.a2.x).to.equal(11)
|
|
expect(pattern.parts.partA.points.a2.y).to.equal(11)
|
|
expect(pattern.parts.partB.points.b1.x).to.equal(2)
|
|
expect(pattern.parts.partB.points.b1.y).to.equal(2)
|
|
expect(pattern.parts.partB.points.b2.x).to.equal(22)
|
|
expect(pattern.parts.partB.points.b2.y).to.equal(22)
|
|
expect(pattern.parts.partC.points.c1.x).to.equal(3)
|
|
expect(pattern.parts.partC.points.c1.y).to.equal(3)
|
|
expect(pattern.parts.partC.points.c2.x).to.equal(33)
|
|
expect(pattern.parts.partC.points.c2.y).to.equal(33)
|
|
expect(pattern.parts.partR.points.r1.x).to.equal(4)
|
|
expect(pattern.parts.partR.points.r1.y).to.equal(4)
|
|
expect(pattern.parts.partR.points.r2.x).to.equal(44)
|
|
expect(pattern.parts.partR.points.r2.y).to.equal(44)
|
|
// Paths in partA
|
|
expect(pattern.parts.partA.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts.partA.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts.partA.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts.partA.paths.a.ops[1].to.y).to.equal(11)
|
|
// Paths in partB
|
|
expect(pattern.parts.partB.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts.partB.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts.partB.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts.partB.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts.partB.paths.b.ops[0].to.x).to.equal(2)
|
|
expect(pattern.parts.partB.paths.b.ops[0].to.y).to.equal(2)
|
|
expect(pattern.parts.partB.paths.b.ops[1].to.x).to.equal(22)
|
|
expect(pattern.parts.partB.paths.b.ops[1].to.y).to.equal(22)
|
|
// Paths in partC
|
|
expect(pattern.parts.partC.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts.partC.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts.partC.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts.partC.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts.partC.paths.b.ops[0].to.x).to.equal(2)
|
|
expect(pattern.parts.partC.paths.b.ops[0].to.y).to.equal(2)
|
|
expect(pattern.parts.partC.paths.b.ops[1].to.x).to.equal(22)
|
|
expect(pattern.parts.partC.paths.b.ops[1].to.y).to.equal(22)
|
|
expect(pattern.parts.partC.paths.c.ops[0].to.x).to.equal(3)
|
|
expect(pattern.parts.partC.paths.c.ops[0].to.y).to.equal(3)
|
|
expect(pattern.parts.partC.paths.c.ops[1].to.x).to.equal(33)
|
|
expect(pattern.parts.partC.paths.c.ops[1].to.y).to.equal(33)
|
|
// Paths in partR
|
|
expect(pattern.parts.partC.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts.partC.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts.partC.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts.partC.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts.partR.paths.r.ops[0].to.x).to.equal(4)
|
|
expect(pattern.parts.partR.paths.r.ops[0].to.y).to.equal(4)
|
|
expect(pattern.parts.partR.paths.r.ops[1].to.x).to.equal(44)
|
|
expect(pattern.parts.partR.paths.r.ops[1].to.y).to.equal(44)
|
|
})
|
|
*/
|
|
it("Design constructor should resolve nested dependencies (2022)", () => {
|
|
const partA = {
|
|
name: "partA",
|
|
options: { optionA: { bool: true } },
|
|
measurements: [ 'measieA' ],
|
|
optionalMeasurements: [ 'optmeasieA' ],
|
|
draft: part => {
|
|
const { points, Point, paths, Path } = part.shorthand()
|
|
points.a1 = new Point(1,1)
|
|
points.a2 = new Point(11,11)
|
|
paths.a = new Path().move(points.a1).line(points.a2)
|
|
return part
|
|
}
|
|
}
|
|
const partB = {
|
|
name: "partB",
|
|
from: partA,
|
|
options: { optionB: { pct: 12, min: 2, max: 20 } },
|
|
measurements: [ 'measieB' ],
|
|
optionalMeasurements: [ 'optmeasieB', 'measieA' ],
|
|
draft: part => {
|
|
const { points, Point, paths, Path } = part.shorthand()
|
|
points.b1 = new Point(2,2)
|
|
points.b2 = new Point(22,22)
|
|
paths.b = new Path().move(points.b1).line(points.b2)
|
|
return part
|
|
}
|
|
}
|
|
const partC = {
|
|
name: "partC",
|
|
from: partB,
|
|
options: { optionC: { deg: 5, min: 0, max: 15 } },
|
|
measurements: [ 'measieC' ],
|
|
optionalMeasurements: [ 'optmeasieC', 'measieA' ],
|
|
draft: part => {
|
|
const { points, Point, paths, Path } = part.shorthand()
|
|
points.c1 = new Point(3,3)
|
|
points.c2 = new Point(33,33)
|
|
paths.c = new Path().move(points.c1).line(points.c2)
|
|
return part
|
|
}
|
|
}
|
|
const partD = {
|
|
name: "partD",
|
|
after: partC,
|
|
options: { optionD: { dflt: 'red', list: ['red', 'green', 'blue'] } },
|
|
measurements: [ 'measieD' ],
|
|
optionalMeasurements: [ 'optmeasieD', 'measieA' ],
|
|
draft: part => {
|
|
const { points, Point, paths, Path } = part.shorthand()
|
|
points.d1 = new Point(4,4)
|
|
points.d2 = new Point(44,44)
|
|
paths.d = new Path().move(points.d1).line(points.d2)
|
|
return part
|
|
}
|
|
}
|
|
const Design = new freesewing.Design({ parts: { partD } });
|
|
const pattern = new Design().draft()
|
|
// Measurements
|
|
expect(pattern.config.measurements.length).to.equal(4)
|
|
expect(pattern.config.measurements.indexOf('measieA') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieB') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieC') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieD') === -1).to.equal(false)
|
|
// Optional measurements
|
|
expect(pattern.config.optionalMeasurements.length).to.equal(4)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieA') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieB') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieC') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieD') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('measieA') === -1).to.equal(true)
|
|
// Options
|
|
expect(pattern.config.options.optionA.bool).to.equal(true)
|
|
expect(pattern.config.options.optionB.pct).to.equal(12)
|
|
expect(pattern.config.options.optionB.min).to.equal(2)
|
|
expect(pattern.config.options.optionB.max).to.equal(20)
|
|
expect(pattern.config.options.optionC.deg).to.equal(5)
|
|
expect(pattern.config.options.optionC.min).to.equal(0)
|
|
expect(pattern.config.options.optionC.max).to.equal(15)
|
|
expect(pattern.config.options.optionD.dflt).to.equal('red')
|
|
expect(pattern.config.options.optionD.list[0]).to.equal('red')
|
|
expect(pattern.config.options.optionD.list[1]).to.equal('green')
|
|
expect(pattern.config.options.optionD.list[2]).to.equal('blue')
|
|
// Dependencies
|
|
expect(pattern.config.dependencies.partB[0]).to.equal('partA')
|
|
expect(pattern.config.dependencies.partC[0]).to.equal('partB')
|
|
expect(pattern.config.dependencies.partD[0]).to.equal('partC')
|
|
// Inject
|
|
expect(pattern.config.inject.partB).to.equal('partA')
|
|
expect(pattern.config.inject.partC).to.equal('partB')
|
|
// Draft order
|
|
expect(pattern.config.draftOrder[0]).to.equal('partA')
|
|
expect(pattern.config.draftOrder[1]).to.equal('partB')
|
|
expect(pattern.config.draftOrder[2]).to.equal('partC')
|
|
expect(pattern.config.draftOrder[3]).to.equal('partD')
|
|
// Points
|
|
expect(pattern.parts.partA.points.a1.x).to.equal(1)
|
|
expect(pattern.parts.partA.points.a1.y).to.equal(1)
|
|
expect(pattern.parts.partA.points.a2.x).to.equal(11)
|
|
expect(pattern.parts.partA.points.a2.y).to.equal(11)
|
|
expect(pattern.parts.partB.points.b1.x).to.equal(2)
|
|
expect(pattern.parts.partB.points.b1.y).to.equal(2)
|
|
expect(pattern.parts.partB.points.b2.x).to.equal(22)
|
|
expect(pattern.parts.partB.points.b2.y).to.equal(22)
|
|
expect(pattern.parts.partC.points.c1.x).to.equal(3)
|
|
expect(pattern.parts.partC.points.c1.y).to.equal(3)
|
|
expect(pattern.parts.partC.points.c2.x).to.equal(33)
|
|
expect(pattern.parts.partC.points.c2.y).to.equal(33)
|
|
expect(pattern.parts.partD.points.d1.x).to.equal(4)
|
|
expect(pattern.parts.partD.points.d1.y).to.equal(4)
|
|
expect(pattern.parts.partD.points.d2.x).to.equal(44)
|
|
expect(pattern.parts.partD.points.d2.y).to.equal(44)
|
|
// Paths in partA
|
|
expect(pattern.parts.partA.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts.partA.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts.partA.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts.partA.paths.a.ops[1].to.y).to.equal(11)
|
|
// Paths in partB
|
|
expect(pattern.parts.partB.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts.partB.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts.partB.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts.partB.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts.partB.paths.b.ops[0].to.x).to.equal(2)
|
|
expect(pattern.parts.partB.paths.b.ops[0].to.y).to.equal(2)
|
|
expect(pattern.parts.partB.paths.b.ops[1].to.x).to.equal(22)
|
|
expect(pattern.parts.partB.paths.b.ops[1].to.y).to.equal(22)
|
|
// Paths in partC
|
|
expect(pattern.parts.partC.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts.partC.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts.partC.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts.partC.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts.partC.paths.b.ops[0].to.x).to.equal(2)
|
|
expect(pattern.parts.partC.paths.b.ops[0].to.y).to.equal(2)
|
|
expect(pattern.parts.partC.paths.b.ops[1].to.x).to.equal(22)
|
|
expect(pattern.parts.partC.paths.b.ops[1].to.y).to.equal(22)
|
|
expect(pattern.parts.partC.paths.c.ops[0].to.x).to.equal(3)
|
|
expect(pattern.parts.partC.paths.c.ops[0].to.y).to.equal(3)
|
|
expect(pattern.parts.partC.paths.c.ops[1].to.x).to.equal(33)
|
|
expect(pattern.parts.partC.paths.c.ops[1].to.y).to.equal(33)
|
|
// Paths in partR
|
|
expect(pattern.parts.partD.paths.d.ops[0].to.x).to.equal(4)
|
|
expect(pattern.parts.partD.paths.d.ops[0].to.y).to.equal(4)
|
|
expect(pattern.parts.partD.paths.d.ops[1].to.x).to.equal(44)
|
|
expect(pattern.parts.partD.paths.d.ops[1].to.y).to.equal(44)
|
|
})
|