zach/dotter

import { describe, expect, test } from 'bun:test';

import { NextDraw } from '../src/nextdraw.js';

import { penLiftTimes, servoSettings } from '../src/pen.js';

import { calcJerk } from '../src/plan.js';

function nd(configure) {

  const n = new NextDraw({ log: () => {} });

  n.interactive();

  configure?.(n);

  n.updateOptions();

  return n;

}

describe('model and handling parameters', () => {

  test('NextDraw 8511 defaults (Technical drawing)', () => {

    const n = nd();

    expect(n.params.modelName).toBe('Bantam Tools NextDraw™ 8511');

    expect(n.params.travelX).toBe(11.81);

    expect(n.params.travelY).toBe(8.58);

    expect(n.params.autoHome).toBe(true);

    expect(n.params.resolution).toBe(1);

    expect(n.params.speedLimit).toBe(8.6979);

    expect(n.params.speedUp).toBe(8.6979);

    expect(n.params.jerkPenDown).toBe(20000);

    expect(n.params.jerkPenUp).toBe(19000);

    expect(n.params.constSpeed).toBe(false);

    // Brushless narrow-band pen-lift servo on pin B2

    expect(n.params.zMotor).toBe(1);

    expect(n.params.servoPin).toBe(2);

    expect([n.params.servoMin, n.params.servoMax]).toEqual([5400, 12600]);

    expect(n.bounds).toEqual([[-1e-9, -1e-9], [11.81 + 1e-9, 8.58 + 1e-9]]);

  });

  test('handling modes', () => {

    const hw = nd((n) => { n.options.handling = 2; });

    expect(hw.params.resolution).toBe(2);

    expect(hw.params.speedLimit).toBe(7);

    expect(hw.params.speedUp).toBe(12);

    expect(hw.params.jerkPenDown).toBe(90000);

    expect(hw.params.jerkPenUp).toBe(13000);

    const sk = nd((n) => { n.options.handling = 3; });

    expect(sk.params.speedLimit).toBe(12);

    const cs = nd((n) => { n.options.handling = 4; });

    expect(cs.params.constSpeed).toBe(true);

    expect(cs.params.speedLimit).toBe(3.0);

    expect(cs.params.resolution).toBe(1);

  });

  test('other models and pen-lift options', () => {

    const a3 = nd((n) => { n.options.model = 2; });

    expect(a3.params.autoHome).toBe(false);

    expect(a3.params.zMotor).toBe(0);

    expect(a3.params.servoPin).toBe(1);

    const upgraded = nd((n) => { n.options.model = 1; n.options.penlift = 3; });

    expect(upgraded.params.zMotor).toBe(1);

    const big = nd((n) => { n.options.model = 10; n.options.handling = 1; });

    expect(big.params.travelX).toBe(34.02);

    expect(big.params.jerkPenDown).toBeCloseTo(20000 * 0.6, 9);

  });

  test('overrides are applied after model defaults', () => {

    const n = nd((x) => { x.params.overrides.travelX = 5; x.params.overrides.speedLimit = 4; });

    expect(n.params.travelX).toBe(5);

    expect(n.params.speedLimit).toBe(4);

    expect(n.bounds[1][0]).toBeCloseTo(5, 6);

  });

  test('invalid model is rejected', () => {

    expect(() => nd((n) => { n.options.model = 11; })).toThrow();

  });

  test('options are clamped to their documented ranges', () => {

    const n = nd((x) => { x.options.penPosUp = 150; x.options.speedPendown = 0; x.options.accel = -5; });

    expect(n.options.penPosUp).toBe(100);

    expect(n.options.speedPendown).toBe(1);

    expect(n.options.accel).toBe(1);

  });

});

describe('pen servo settings', () => {

  test('default positions, rates and lift times', () => {

    const n = nd();

    expect(servoSettings(n, 40)).toEqual({ rateUp: 231, rateDown: 154, posUp: 9720, posDown: 8280 });

    expect(penLiftTimes(n, 40)).toEqual({ raiseTime: 45, lowerTime: 47 });

  });

  test('equal up/down heights need no delay; extra delays are added', () => {

    const n = nd((x) => { x.options.penPosDown = 60; });

    expect(penLiftTimes(n, 60)).toEqual({ raiseTime: 0, lowerTime: 0 });

    const d = nd((x) => { x.params.penDelayUp = 100; x.params.penDelayDown = -1000; });

    const t = penLiftTimes(d, 40);

    expect(t.raiseTime).toBe(145);

    expect(t.lowerTime).toBe(0); // never negative

  });

  test('standard servo uses 8 PWM channels in its rate scale', () => {

    const n = nd((x) => { x.options.model = 2; });

    // range 17976 * 0.24 / 200 = 21.5712 per %

    expect(servoSettings(n, 40)).toEqual({

      rateUp: Math.round(21.5712 * 75), rateDown: Math.round(21.5712 * 50),

      posUp: Math.round(9855 + 179.76 * 60), posDown: Math.round(9855 + 179.76 * 40),

    });

  });

  test('jerk scales with the cube of accel', () => {

    const n = nd((x) => { x.options.accel = 50; });

    const [up, down] = calcJerk(n);

    expect(up).toBeCloseTo(19000 * 0.125, 9);

    expect(down).toBeCloseTo(20000 * 0.125, 9);

  });

});