@flighthq/path 0.1.0

package/dist/transformPath.js

@@ -0,0 +1,62 @@
+import { PathCommand } from '@flighthq/types';
+import { copyPath } from './copyPath';
+// Applies a 2D affine matrix to all anchor and control-point coordinate pairs in `source`, writing
+// the result into `out`. `out` may be the same object as `source` (alias-safe: inputs are read into
+// locals before writing). Commands and winding are copied unchanged.
+//
+// Matrix layout: [a c tx]   x' = a*x + c*y + tx
+//                [b d ty]   y' = b*x + d*y + ty
+export function transformPath(source, matrix, out) {
+    const { a, b, c, d, tx, ty } = matrix;
+    // Copy commands and winding first (handles the alias case for the data array below).
+    copyPath(source, out);
+    const data = out.data;
+    const commands = source.commands;
+    let di = 0;
+    for (let ci = 0; ci < commands.length; ci++) {
+        const command = commands[ci];
+        if (command === PathCommand.MOVE_TO || command === PathCommand.LINE_TO) {
+            // 2 values: x, y
+            const x = data[di];
+            const y = data[di + 1];
+            data[di] = a * x + c * y + tx;
+            data[di + 1] = b * x + d * y + ty;
+            di += 2;
+        }
+        else if (command === PathCommand.CURVE_TO) {
+            // 4 values: controlX, controlY, anchorX, anchorY
+            for (let k = 0; k < 4; k += 2) {
+                const x = data[di + k];
+                const y = data[di + k + 1];
+                data[di + k] = a * x + c * y + tx;
+                data[di + k + 1] = b * x + d * y + ty;
+            }
+            di += 4;
+        }
+        else if (command === PathCommand.CUBIC_CURVE_TO) {
+            // 6 values: control1X, control1Y, control2X, control2Y, anchorX, anchorY
+            for (let k = 0; k < 6; k += 2) {
+                const x = data[di + k];
+                const y = data[di + k + 1];
+                data[di + k] = a * x + c * y + tx;
+                data[di + k + 1] = b * x + d * y + ty;
+            }
+            di += 6;
+        }
+        else if (command === PathCommand.WIDE_MOVE_TO || command === PathCommand.WIDE_LINE_TO) {
+            // 4 values: dummy pair + real x, y. Only the real pair at [di+2, di+3] is transformed.
+            const x = data[di + 2];
+            const y = data[di + 3];
+            data[di + 2] = a * x + c * y + tx;
+            data[di + 3] = b * x + d * y + ty;
+            di += 4;
+        }
+        // CLOSE, NO_OP, and unrecognized verbs consume no data.
+    }
+}
+// Translates all points in `source` by (dx, dy), writing the result into `out`. Alias-safe.
+// This is a convenience wrapper around `transformPath` for the common pure-translate case.
+export function translatePath(source, dx, dy, out) {
+    transformPath(source, { a: 1, b: 0, c: 0, d: 1, tx: dx, ty: dy }, out);
+}
+//# sourceMappingURL=transformPath.js.map

package/dist/transformPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformPath.js","sourceRoot":"","sources":["../src/transformPath.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@flighthq/path",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Vector path geometry: curve flattening and tessellation of GraphicsPath outlines",
+  "sideEffects": false
+}

package/src/containsPathPoint.test.ts

@@ -0,0 +1,125 @@
+import { PathCommand } from '@flighthq/types';
+
+import { containsPathPoint } from './containsPathPoint';
+import { appendPathCubicCurveTo, appendPathCurveTo, appendPathLineTo, appendPathMoveTo, createPath } from './path';
+
+describe('containsPathPoint', () => {
+  it('returns true for a point inside a convex polygon (nonZero)', () => {
+    const path = createPath('nonZero');
+    // Unit square [0,0]→[100,100]
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 100, 100);
+    appendPathLineTo(path, 0, 100);
+    appendPathLineTo(path, 0, 0);
+    expect(containsPathPoint(path, 50, 50)).toBe(true);
+  });
+
+  it('returns false for a point outside a convex polygon (nonZero)', () => {
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 100, 100);
+    appendPathLineTo(path, 0, 100);
+    appendPathLineTo(path, 0, 0);
+    expect(containsPathPoint(path, 200, 200)).toBe(false);
+  });
+
+  it('returns true for a point inside a convex polygon (evenOdd)', () => {
+    const path = createPath('evenOdd');
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 100, 100);
+    appendPathLineTo(path, 0, 100);
+    appendPathLineTo(path, 0, 0);
+    expect(containsPathPoint(path, 50, 50)).toBe(true);
+  });
+
+  it('returns false for a point in a hole (evenOdd — concave figure-8 crossing)', () => {
+    // Overlapping two CCW squares: the overlapping center is a "hole" in evenOdd.
+    const path = createPath('evenOdd');
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 60, 0);
+    appendPathLineTo(path, 60, 60);
+    appendPathLineTo(path, 0, 60);
+    appendPathLineTo(path, 0, 0);
+    appendPathMoveTo(path, 40, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 100, 60);
+    appendPathLineTo(path, 40, 60);
+    appendPathLineTo(path, 40, 0);
+    // Point at x=50, y=30 is inside BOTH squares → evenOdd makes it a hole
+    expect(containsPathPoint(path, 50, 30)).toBe(false);
+    // Point at x=20, y=30 is inside only the first square → inside
+    expect(containsPathPoint(path, 20, 30)).toBe(true);
+  });
+
+  it('returns true for a point inside the inner ring (nonZero — same winding union)', () => {
+    // nonZero with two same-direction overlapping squares → union, center is inside
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 60, 0);
+    appendPathLineTo(path, 60, 60);
+    appendPathLineTo(path, 0, 60);
+    appendPathLineTo(path, 0, 0);
+    appendPathMoveTo(path, 40, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 100, 60);
+    appendPathLineTo(path, 40, 60);
+    appendPathLineTo(path, 40, 0);
+    expect(containsPathPoint(path, 50, 30)).toBe(true);
+  });
+
+  it('handles a quadratic curve contour', () => {
+    // Approximate a quarter-circle using a single quadratic — the interior should register a hit.
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 100, 0);
+    appendPathCurveTo(path, 100, 100, 0, 100);
+    appendPathLineTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    expect(containsPathPoint(path, 30, 30)).toBe(true);
+    expect(containsPathPoint(path, 90, 90)).toBe(false);
+  });
+
+  it('handles a cubic curve contour', () => {
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathCubicCurveTo(path, 100, 33, 100, 66, 100, 100);
+    appendPathLineTo(path, 0, 100);
+    appendPathLineTo(path, 0, 0);
+    expect(containsPathPoint(path, 50, 50)).toBe(true);
+    expect(containsPathPoint(path, 150, 50)).toBe(false);
+  });
+
+  it('returns false for an empty path', () => {
+    const path = createPath('nonZero');
+    expect(containsPathPoint(path, 0, 0)).toBe(false);
+  });
+
+  it('handles a WIDE_MOVE_TO command', () => {
+    const path = createPath('nonZero');
+    path.commands.push(PathCommand.WIDE_MOVE_TO);
+    path.data.push(0, 0, 0, 0); // dummy pair + real point (0,0)
+    path.commands.push(PathCommand.LINE_TO);
+    path.data.push(100, 0);
+    path.commands.push(PathCommand.LINE_TO);
+    path.data.push(100, 100);
+    path.commands.push(PathCommand.LINE_TO);
+    path.data.push(0, 100);
+    path.commands.push(PathCommand.LINE_TO);
+    path.data.push(0, 0);
+    expect(containsPathPoint(path, 50, 50)).toBe(true);
+  });
+
+  it('handles a WIDE_LINE_TO command', () => {
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 0, 0);
+    path.commands.push(PathCommand.WIDE_LINE_TO);
+    path.data.push(0, 0, 100, 0); // dummy pair + real point (100,0)
+    appendPathLineTo(path, 100, 100);
+    appendPathLineTo(path, 0, 100);
+    appendPathLineTo(path, 0, 0);
+    expect(containsPathPoint(path, 50, 50)).toBe(true);
+  });
+});

package/src/copyPath.test.ts

@@ -0,0 +1,56 @@
+import { clonePath, copyPath } from './copyPath';
+import { appendPathLineTo, appendPathMoveTo, appendPathRectangle, createPath } from './path';
+
+describe('clonePath', () => {
+  it('returns a new path with the same commands and data', () => {
+    const source = createPath('evenOdd');
+    appendPathRectangle(source, 0, 0, 100, 50);
+    const clone = clonePath(source);
+    expect(clone).not.toBe(source);
+    expect(clone.commands).toStrictEqual(source.commands);
+    expect(clone.data).toStrictEqual(source.data);
+    expect(clone.winding).toBe('evenOdd');
+  });
+
+  it('mutations to the clone do not affect the source', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    const clone = clonePath(source);
+    clone.commands.push(99);
+    expect(source.commands.length).toBe(1);
+  });
+});
+
+describe('copyPath', () => {
+  it('allocates a new path when out is omitted', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 5, 10);
+    const result = copyPath(source);
+    expect(result).not.toBe(source);
+    expect(result.commands).toStrictEqual(source.commands);
+    expect(result.data).toStrictEqual(source.data);
+  });
+
+  it('writes into out when provided', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 1, 2);
+    appendPathLineTo(source, 3, 4);
+    const out = createPath('evenOdd');
+    const result = copyPath(source, out);
+    expect(result).toBe(out);
+    expect(out.commands).toStrictEqual(source.commands);
+    expect(out.data).toStrictEqual(source.data);
+    expect(out.winding).toBe('nonZero');
+  });
+
+  it('is a no-op when out is the same object as source', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 7, 8);
+    const cmdsBefore = source.commands.slice();
+    const dataBefore = source.data.slice();
+    const result = copyPath(source, source);
+    expect(result).toBe(source);
+    expect(source.commands).toStrictEqual(cmdsBefore);
+    expect(source.data).toStrictEqual(dataBefore);
+  });
+});

package/src/dashPath.test.ts

@@ -0,0 +1,76 @@
+import { PathCommand } from '@flighthq/types';
+
+import { dashPath } from './dashPath';
+import { appendPathClose, appendPathLineTo, appendPathMoveTo, createPath } from './path';
+
+describe('dashPath', () => {
+  it('produces dashed segments from a simple line', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 100, 0);
+    const out = createPath();
+    dashPath(source, [10, 5], 0, out);
+
+    // Each dash-on segment starts with MOVE_TO and has LINE_TOs.
+    const moves = out.commands.filter((c) => c === PathCommand.MOVE_TO);
+    expect(moves.length).toBeGreaterThanOrEqual(6);
+    expect(out.commands).not.toContain(PathCommand.CLOSE);
+  });
+
+  it('copies the source unchanged for an empty dash array', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 50, 50);
+    const out = createPath();
+    dashPath(source, [], 0, out);
+
+    expect(out.commands).toStrictEqual(source.commands);
+    expect(out.data).toStrictEqual(source.data);
+  });
+
+  it('handles a closed path', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 100, 0);
+    appendPathLineTo(source, 100, 100);
+    appendPathClose(source);
+    const out = createPath();
+    dashPath(source, [20, 10], 0, out);
+
+    const moves = out.commands.filter((c) => c === PathCommand.MOVE_TO);
+    expect(moves.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('applies dash offset correctly', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 100, 0);
+    const noOffset = createPath();
+    dashPath(source, [10, 10], 0, noOffset);
+    const withOffset = createPath();
+    dashPath(source, [10, 10], 5, withOffset);
+
+    // The first segment with offset=5 starts at x=0 but the on-phase is only 5 units.
+    // So the data should differ.
+    expect(withOffset.data).not.toStrictEqual(noOffset.data);
+  });
+
+  it('handles zero-length segments in the dash array', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 50, 0);
+    const out = createPath();
+    // Zero gap means continuous — effectively all on.
+    dashPath(source, [10, 0], 0, out);
+    expect(out.commands.length).toBeGreaterThan(0);
+  });
+
+  it('preserves winding rule', () => {
+    const source = createPath('evenOdd');
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 100, 0);
+    const out = createPath();
+    dashPath(source, [10, 5], 0, out);
+    expect(out.winding).toBe('evenOdd');
+  });
+});

package/src/fitPathCurves.test.ts

@@ -0,0 +1,65 @@
+import { PathCommand } from '@flighthq/types';
+
+import { fitPathCurves } from './fitPathCurves';
+import { appendPathLineTo, appendPathMoveTo, createPath } from './path';
+
+describe('fitPathCurves', () => {
+  it('keeps a straight line as a line', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 50, 0);
+    appendPathLineTo(source, 100, 0);
+    const out = createPath();
+    fitPathCurves(source, 1, out);
+    expect(out.commands[0]).toBe(PathCommand.MOVE_TO);
+    expect(out.commands).not.toContain(PathCommand.CLOSE);
+    const lastX = out.data[out.data.length - 2];
+    const lastY = out.data[out.data.length - 1];
+    expect(lastX).toBeCloseTo(100);
+    expect(lastY).toBeCloseTo(0);
+  });
+
+  it('produces smooth curves from a circle-like polyline', () => {
+    const source = createPath();
+    const n = 16;
+    const r = 50;
+    for (let i = 0; i < n; i++) {
+      const angle = (i / n) * Math.PI * 2;
+      const x = Math.cos(angle) * r;
+      const y = Math.sin(angle) * r;
+      if (i === 0) appendPathMoveTo(source, x, y);
+      else appendPathLineTo(source, x, y);
+    }
+    const out = createPath();
+    fitPathCurves(source, 1, out);
+    expect(out.commands).toContain(PathCommand.CUBIC_CURVE_TO);
+    const cubicCount = out.commands.filter((c) => c === PathCommand.CUBIC_CURVE_TO).length;
+    expect(cubicCount).toBeLessThan(n);
+  });
+
+  it('handles a single segment', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 100, 100);
+    const out = createPath();
+    fitPathCurves(source, 1, out);
+    expect(out.commands[0]).toBe(PathCommand.MOVE_TO);
+    expect(out.data).toContain(100);
+  });
+
+  it('handles an empty path', () => {
+    const out = createPath();
+    fitPathCurves(createPath(), 1, out);
+    expect(out.commands).toStrictEqual([]);
+  });
+
+  it('preserves winding rule', () => {
+    const source = createPath('evenOdd');
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 100, 0);
+    appendPathLineTo(source, 100, 100);
+    const out = createPath();
+    fitPathCurves(source, 1, out);
+    expect(out.winding).toBe('evenOdd');
+  });
+});

package/src/flattenPath.test.ts

@@ -0,0 +1,87 @@
+import type { Path } from '@flighthq/types';
+import { PathCommand } from '@flighthq/types';
+
+import { flattenPath } from './flattenPath';
+import { appendPathClose, appendPathCurveTo, appendPathLineTo, appendPathMoveTo, createPath } from './path';
+
+describe('flattenPath', () => {
+  it('flattens a straight line to its two endpoints', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    expect(flattenPath(path)).toStrictEqual([[0, 0, 100, 0]]);
+  });
+
+  it('produces one contour per subpath', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 10, 0);
+    appendPathMoveTo(path, 0, 10);
+    appendPathLineTo(path, 10, 10);
+    const contours = flattenPath(path);
+    expect(contours).toStrictEqual([
+      [0, 0, 10, 0],
+      [0, 10, 10, 10],
+    ]);
+  });
+
+  it('collapses a quadratic whose control lies on the chord to just the endpoint', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathCurveTo(path, 50, 0, 100, 0);
+    expect(flattenPath(path)).toStrictEqual([[0, 0, 100, 0]]);
+  });
+
+  it('subdivides a genuinely curved quadratic, keeping the endpoints', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathCurveTo(path, 50, 50, 100, 0);
+    const contour = flattenPath(path)[0];
+    expect(contour.length).toBeGreaterThan(4); // more than just start + end
+    expect(contour[0]).toBe(0);
+    expect(contour[1]).toBe(0);
+    expect(contour[contour.length - 2]).toBe(100);
+    expect(contour[contour.length - 1]).toBe(0);
+  });
+
+  it('reads the second coordinate pair for WIDE_ verbs', () => {
+    const path: Path = {
+      commands: [PathCommand.WIDE_MOVE_TO, PathCommand.WIDE_LINE_TO],
+      data: [0, 0, 5, 6, 0, 0, 7, 8],
+      winding: 'nonZero',
+    };
+    expect(flattenPath(path)).toStrictEqual([[5, 6, 7, 8]]);
+  });
+
+  it('emits fewer points at a coarser tolerance', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathCurveTo(path, 50, 50, 100, 0);
+    const fine = flattenPath(path, 0.1)[0].length;
+    const coarse = flattenPath(path, 50)[0].length;
+    expect(coarse).toBeLessThan(fine);
+  });
+
+  it('appends the start point when a CLOSE verb is present and position differs', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 100, 100);
+    appendPathClose(path);
+    const contour = flattenPath(path)[0];
+    // Should end at the start point (0,0)
+    expect(contour[contour.length - 2]).toBe(0);
+    expect(contour[contour.length - 1]).toBe(0);
+  });
+
+  it('does not duplicate the start point when CLOSE is at the same position', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 0, 0); // already at start
+    appendPathClose(path);
+    const contour = flattenPath(path)[0];
+    // Length should be 6: (0,0), (100,0), (0,0) — no duplicate close point
+    expect(contour.length).toBe(6);
+  });
+});

package/src/forEachPathSegment.test.ts

@@ -0,0 +1,82 @@
+import type { PathSegment } from '@flighthq/types';
+import { PathCommand } from '@flighthq/types';
+
+import { forEachPathSegment } from './forEachPathSegment';
+import {
+  appendPathClose,
+  appendPathCubicCurveTo,
+  appendPathCurveTo,
+  appendPathLineTo,
+  appendPathMoveTo,
+  createPath,
+} from './path';
+
+describe('forEachPathSegment', () => {
+  it('visits nothing for an empty path', () => {
+    const segments: PathSegment[] = [];
+    forEachPathSegment(createPath(), (s) => segments.push(s));
+    expect(segments).toStrictEqual([]);
+  });
+  it('yields moveTo and lineTo segments in order', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 1, 2);
+    appendPathLineTo(path, 3, 4);
+    const segments: PathSegment[] = [];
+    forEachPathSegment(path, (s) => segments.push(s));
+    expect(segments).toStrictEqual([
+      { kind: 'moveTo', x: 1, y: 2 },
+      { kind: 'lineTo', x: 3, y: 4 },
+    ]);
+  });
+  it('yields a curveTo segment with correct coordinates', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathCurveTo(path, 10, 20, 30, 0);
+    const segments: PathSegment[] = [];
+    forEachPathSegment(path, (s) => segments.push(s));
+    expect(segments[1]).toStrictEqual({ kind: 'curveTo', controlX: 10, controlY: 20, x: 30, y: 0 });
+  });
+  it('yields a cubicCurveTo segment with correct coordinates', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathCubicCurveTo(path, 10, 20, 30, 40, 50, 0);
+    const segments: PathSegment[] = [];
+    forEachPathSegment(path, (s) => segments.push(s));
+    expect(segments[1]).toStrictEqual({
+      kind: 'cubicCurveTo',
+      control1X: 10,
+      control1Y: 20,
+      control2X: 30,
+      control2Y: 40,
+      x: 50,
+      y: 0,
+    });
+  });
+  it('yields a close segment', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 10, 0);
+    appendPathClose(path);
+    const segments: PathSegment[] = [];
+    forEachPathSegment(path, (s) => segments.push(s));
+    expect(segments[2]).toStrictEqual({ kind: 'close' });
+  });
+  it('normalizes WIDE_MOVE_TO to moveTo', () => {
+    const path = createPath();
+    path.commands.push(PathCommand.WIDE_MOVE_TO);
+    path.data.push(0, 0, 5, 6);
+    const segments: PathSegment[] = [];
+    forEachPathSegment(path, (s) => segments.push(s));
+    expect(segments).toStrictEqual([{ kind: 'moveTo', x: 5, y: 6 }]);
+  });
+  it('normalizes WIDE_LINE_TO to lineTo', () => {
+    const path = createPath();
+    path.commands.push(PathCommand.WIDE_MOVE_TO);
+    path.data.push(0, 0, 0, 0);
+    path.commands.push(PathCommand.WIDE_LINE_TO);
+    path.data.push(0, 0, 7, 8);
+    const segments: PathSegment[] = [];
+    forEachPathSegment(path, (s) => segments.push(s));
+    expect(segments[1]).toStrictEqual({ kind: 'lineTo', x: 7, y: 8 });
+  });
+});

package/src/getPathBounds.test.ts

@@ -0,0 +1,84 @@
+import { getPathBounds } from './getPathBounds';
+import {
+  appendPathCubicCurveTo,
+  appendPathCurveTo,
+  appendPathLineTo,
+  appendPathMoveTo,
+  appendPathRectangle,
+  createPath,
+} from './path';
+
+describe('getPathBounds', () => {
+  it('returns false and a zero rect for an empty path', () => {
+    const path = createPath();
+    const out = { x: 1, y: 2, width: 3, height: 4 };
+    const result = getPathBounds(path, out);
+    expect(result).toBe(false);
+    expect(out).toStrictEqual({ x: 0, y: 0, width: 0, height: 0 });
+  });
+
+  it('returns the exact bounds of a rectangle', () => {
+    const path = createPath();
+    appendPathRectangle(path, 10, 20, 100, 50);
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    const result = getPathBounds(path, out);
+    expect(result).toBe(true);
+    expect(out.x).toBeCloseTo(10);
+    expect(out.y).toBeCloseTo(20);
+    expect(out.width).toBeCloseTo(100);
+    expect(out.height).toBeCloseTo(50);
+  });
+
+  it('includes the start point of a single MOVE_TO', () => {
+    const path = createPath();
+    appendPathMoveTo(path, 5, 7);
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    getPathBounds(path, out);
+    expect(out.x).toBeCloseTo(5);
+    expect(out.y).toBeCloseTo(7);
+    expect(out.width).toBeCloseTo(0);
+    expect(out.height).toBeCloseTo(0);
+  });
+
+  it('expands past control points for a quadratic curve', () => {
+    // A quadratic arc: start=(0,0) control=(50,100) end=(100,0)
+    // The true Y maximum is at t=0.5: B(0.5)=(25+0.5*50, 50+…) = (50, 50) — 50 not 100.
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathCurveTo(path, 50, 100, 100, 0);
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    getPathBounds(path, out);
+    expect(out.x).toBeCloseTo(0);
+    expect(out.y).toBeCloseTo(0);
+    // True Y max for this curve = 50 (at t=0.5), not 100 (the control point)
+    expect(out.height).toBeCloseTo(50);
+    expect(out.width).toBeCloseTo(100);
+  });
+
+  it('expands past control points for a cubic curve', () => {
+    // A symmetric cubic: start=(0,0) c1=(0,100) c2=(100,100) end=(100,0).
+    // The true Y extremum is somewhere between 0 and 100.
+    const path = createPath();
+    appendPathMoveTo(path, 0, 0);
+    appendPathCubicCurveTo(path, 0, 100, 100, 100, 100, 0);
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    getPathBounds(path, out);
+    // The maximum y should be ~75 (the bezier peak for this configuration)
+    expect(out.y).toBeCloseTo(0);
+    expect(out.height).toBeGreaterThan(70);
+    expect(out.height).toBeLessThan(100);
+    expect(out.width).toBeCloseTo(100);
+  });
+
+  it('handles a MOVE_TO + LINE_TO spanning multiple quadrants', () => {
+    const path = createPath();
+    appendPathMoveTo(path, -50, -30);
+    appendPathLineTo(path, 80, 60);
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    getPathBounds(path, out);
+    expect(out.x).toBeCloseTo(-50);
+    expect(out.y).toBeCloseTo(-30);
+    expect(out.width).toBeCloseTo(130);
+    expect(out.height).toBeCloseTo(90);
+  });
+});