zach/dotter

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

import { apply, documentFrame, joinPolylines, lengthToInches, parsePathData, parseTransform,

  shapeToPathData, svgToPolylines } from '../src/svg.js';

import { distanceToPolylines } from './helpers.js';

/** Minimal element stand-in so the SVG walker can be tested without a DOM. */

function el(localName, attrs = {}, children = []) {

  return {

    localName,

    children,

    getAttribute: (k) => (k in attrs ? String(attrs[k]) : null),

    hasAttribute: (k) => k in attrs,

  };

}

describe('lengths and transforms', () => {

  test('units', () => {

    expect(lengthToInches('8.5in')).toBe(8.5);

    expect(lengthToInches('25.4mm')).toBeCloseTo(1, 12);

    expect(lengthToInches('2.54cm')).toBeCloseTo(1, 12);

    expect(lengthToInches('96')).toBe(1);

    expect(lengthToInches('72pt')).toBe(1);

    expect(lengthToInches('100%')).toBe(null);

    expect(lengthToInches(null)).toBe(null);

  });

  test('transform lists compose left to right', () => {

    const m = parseTransform('translate(10, 5) scale(2) rotate(90)');

    const [x, y] = apply(m, [1, 0]);

    expect(x).toBeCloseTo(10, 12);

    expect(y).toBeCloseTo(7, 12);

    const r = parseTransform('rotate(180 5 5)');

    expect(apply(r, [0, 0]).map((v) => Math.round(v * 1e9) / 1e9)).toEqual([10, 10]);

    expect(parseTransform('matrix(1,0,0,1,3,4)')).toEqual([1, 0, 0, 1, 3, 4]);

  });

});

describe('path data', () => {

  test('lines, relative commands, implicit linetos, close', () => {

    const subs = parsePathData('M10 10 l 5 0 0 5 H 10 z m 20 0 h 1');

    expect(subs[0]).toEqual([[10, 10], [15, 10], [15, 15], [10, 15], [10, 10]]);

    expect(subs[1]).toEqual([[30, 10], [31, 10]]);

  });

  test('cubic flattening stays within tolerance', () => {

    const tol = 0.01;

    const [pts] = parsePathData('M0,0 C 0,10 10,10 10,0', tol);

    // B(t) for control points (0,0) (0,10) (10,10) (10,0)

    const bez = (t) => [3 * t * t * (1 - t) * 10 + t ** 3 * 10, 3 * t * (1 - t) ** 2 * 10 + 3 * t * t * (1 - t) * 10];

    for (let i = 0; i <= 100; i++) expect(distanceToPolylines(bez(i / 100), [pts])).toBeLessThan(tol * 1.5);

    expect(pts[pts.length - 1]).toEqual([10, 0]);

  });

  test('arcs: a semicircle', () => {

    const tol = 0.001;

    const [pts] = parsePathData('M 0 0 A 5 5 0 0 1 10 0', tol);

    for (const [x, y] of pts) expect(Math.abs(Math.hypot(x - 5, y) - 5)).toBeLessThan(tol * 1.01);

    expect(pts[pts.length - 1]).toEqual([10, 0]);

    // sweep=1 from (0,0) to (10,0) goes through negative y (SVG y points down)

    expect(Math.min(...pts.map((p) => p[1]))).toBeCloseTo(-5, 2);

  });

  test('quadratic and smooth curves', () => {

    const subs = parsePathData('M0 0 Q 5 10 10 0 T 20 0 M0 20 C 0 25 5 25 5 20 S 10 15 10 20');

    expect(subs.length).toBe(2);

    expect(subs[0][subs[0].length - 1]).toEqual([20, 0]);

    expect(subs[1][subs[1].length - 1]).toEqual([10, 20]);

  });

  test('garbage input does not throw', () => {

    expect(parsePathData('not a path')).toEqual([]);

    expect(parsePathData('M 1')).toEqual([]);

  });

});

describe('shapes and documents', () => {

  test('basic shapes become path data', () => {

    expect(shapeToPathData('rect', el('rect', { x: 1, y: 2, width: 3, height: 4 }))).toBe('M1,2H4V6H1Z');

    expect(shapeToPathData('line', el('line', { x1: 0, y1: 0, x2: 1, y2: 1 }))).toBe('M0,0 L1,1');

    expect(shapeToPathData('polygon', el('polygon', { points: '0,0 1,0 1,1' }))).toBe('M0,0 1,0 1,1Z');

    expect(shapeToPathData('circle', el('circle', { r: 0 }))).toBe(null);

  });

  test('viewBox maps user units to inches', () => {

    const f = documentFrame(el('svg', { width: '4in', height: '2in', viewBox: '0 0 400 200' }));

    expect(f.width).toBe(4);

    expect(apply(f.matrix, [400, 200])).toEqual([4, 2]);

  });

  test('document walk: nested transforms, hidden and defs skipped', () => {

    const doc = el('svg', { width: '10in', height: '5in', viewBox: '0 0 10 5' }, [

      el('g', { transform: 'translate(1,1)' }, [

        el('line', { x1: 0, y1: 0, x2: 2, y2: 0 }),

        el('rect', { x: 0, y: 0, width: 1, height: 1, style: 'display:none' }),

      ]),

      el('defs', {}, [el('line', { x1: 0, y1: 0, x2: 9, y2: 0 })]),

    ]);

    const { polylines, rotated } = svgToPolylines(doc);

    expect(rotated).toBe(false);

    expect(polylines).toEqual([[[1, 1], [3, 1]]]);

  });

  test('portrait pages rotate to fit the landscape travel', () => {

    const doc = el('svg', { width: '8.5in', height: '11in', viewBox: '0 0 8.5 11' }, [

      el('line', { x1: 0, y1: 0, x2: 0, y2: 11 }),

    ]);

    const r = svgToPolylines(doc);

    expect(r.rotated).toBe(true);

    expect([r.width, r.height]).toEqual([11, 8.5]);

    for (const [x, y] of r.polylines[0]) {

      expect(x).toBeGreaterThanOrEqual(0);

      expect(x).toBeLessThanOrEqual(11);

      expect(y).toBeCloseTo(8.5, 9);

    }

  });

  test('joinPolylines merges touching paths only', () => {

    const joined = joinPolylines([[[0, 0], [1, 0]], [[1, 0.001], [2, 0]], [[5, 5], [6, 6]]]);

    expect(joined).toEqual([[[0, 0], [1, 0], [2, 0]], [[5, 5], [6, 6]]]);

  });

});