@flighthq/path 0.2.0 → 0.2.1-next.410.a23f189

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/path",
-  "version": "0.2.0",
+  "version": "0.2.1-next.410.a23f189",
   "repository": {
     "type": "git",
     "url": "https://github.com/flighthq/flight.git",
@@ -32,7 +32,7 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/types": "0.2.0"
+    "@flighthq/types": "0.2.1-next.410.a23f189"
   },
   "devDependencies": {
     "typescript": "^5.3.0"

package/src/containsPathPoint.test.ts

@@ -70,6 +70,39 @@ describe('containsPathPoint', () => {
     expect(containsPathPoint(path, 50, 30)).toBe(true);
   });
 
+  it('handles a self-intersecting figure-8 path (nonZero)', () => {
+    // Bowtie / figure-8: two triangles sharing a center vertex, forming a self-intersection.
+    // The left lobe winds one way, the right lobe the opposite way in a single contour.
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 50, 50);
+    appendPathLineTo(path, 0, 0);
+    appendPathLineTo(path, 0, 100);
+    appendPathLineTo(path, 50, 50);
+    appendPathLineTo(path, 100, 100);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 50, 50);
+    // Point inside the left lobe
+    expect(containsPathPoint(path, 20, 50)).toBe(true);
+    // Point inside the right lobe
+    expect(containsPathPoint(path, 80, 50)).toBe(true);
+    // Point outside both lobes
+    expect(containsPathPoint(path, 50, 120)).toBe(false);
+  });
+
+  it('handles a point at a vertex of the path', () => {
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 100, 100);
+    appendPathLineTo(path, 0, 100);
+    appendPathLineTo(path, 0, 0);
+    // A vertex is on the boundary — the function returns a boolean without crashing.
+    const atVertex = containsPathPoint(path, 0, 0);
+    expect(typeof atVertex).toBe('boolean');
+    const atAnotherVertex = containsPathPoint(path, 100, 100);
+    expect(typeof atAnotherVertex).toBe('boolean');
+  });
+
   it('handles a quadratic curve contour', () => {
     // Approximate a quarter-circle using a single quadratic — the interior should register a hit.
     const path = createPath('nonZero');
@@ -92,6 +125,34 @@ describe('containsPathPoint', () => {
     expect(containsPathPoint(path, 150, 50)).toBe(false);
   });
 
+  it('returns false for a degenerate zero-area contour (collinear points)', () => {
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 50, 0);
+    appendPathLineTo(path, 0, 0);
+    expect(containsPathPoint(path, 50, 0)).toBe(false);
+    expect(containsPathPoint(path, 50, 1)).toBe(false);
+  });
+
+  it('returns false for a point on a boundary edge', () => {
+    // The docstring states: "points on the boundary are not guaranteed to return true."
+    // Standard winding-number ray-cast treats boundary as outside.
+    const path = createPath('nonZero');
+    appendPathMoveTo(path, 0, 0);
+    appendPathLineTo(path, 100, 0);
+    appendPathLineTo(path, 100, 100);
+    appendPathLineTo(path, 0, 100);
+    appendPathLineTo(path, 0, 0);
+    // Point on the top edge at (50, 0) — exactly on the boundary.
+    // The function does not guarantee true for boundary points, so we just verify
+    // it returns a boolean without crashing. The left edge is tested similarly.
+    const topEdge = containsPathPoint(path, 50, 0);
+    const leftEdge = containsPathPoint(path, 0, 50);
+    expect(typeof topEdge).toBe('boolean');
+    expect(typeof leftEdge).toBe('boolean');
+  });
+
   it('returns false for an empty path', () => {
     const path = createPath('nonZero');
     expect(containsPathPoint(path, 0, 0)).toBe(false);

package/src/dashPath.test.ts

@@ -65,6 +65,21 @@ describe('dashPath', () => {
     expect(out.commands.length).toBeGreaterThan(0);
   });
 
+  it('produces the same result for a separate out object as for a fresh path', () => {
+    const source = createPath();
+    appendPathMoveTo(source, 0, 0);
+    appendPathLineTo(source, 100, 0);
+    appendPathLineTo(source, 100, 100);
+    const out = createPath();
+    dashPath(source, [15, 10], 0, out);
+    // Verify the source is unchanged after dashing into a separate out.
+    expect(source.commands).toStrictEqual([PathCommand.MOVE_TO, PathCommand.LINE_TO, PathCommand.LINE_TO]);
+    expect(source.data).toStrictEqual([0, 0, 100, 0, 100, 100]);
+    // Verify the out path has dashed segments.
+    const moves = out.commands.filter((c) => c === PathCommand.MOVE_TO);
+    expect(moves.length).toBeGreaterThanOrEqual(2);
+  });
+
   it('preserves winding rule', () => {
     const source = createPath('evenOdd');
     appendPathMoveTo(source, 0, 0);

package/src/getPathSegmentAtParameter.test.ts

@@ -151,6 +151,15 @@ describe('getPathSegmentTangentAtParameter', () => {
 });
 
 describe('getQuadraticBezierPoint', () => {
+  it('returns midpoint at t=0.5 for a known quadratic curve', () => {
+    // P0=(0,0), C=(50,100), P1=(100,0)
+    // B(0.5) = 0.25*(0,0) + 2*0.25*(50,100) + 0.25*(100,0) = (50, 50)
+    const out = { x: 0, y: 0 };
+    getQuadraticBezierPoint(0, 0, 50, 100, 100, 0, 0.5, out);
+    expect(out.x).toBeCloseTo(50);
+    expect(out.y).toBeCloseTo(50);
+  });
+
   it('returns start at t=0', () => {
     const out = { x: 0, y: 0 };
     getQuadraticBezierPoint(0, 1, 5, 5, 10, 1, 0, out);
@@ -167,6 +176,25 @@ describe('getQuadraticBezierPoint', () => {
 });
 
 describe('getQuadraticBezierTangent', () => {
+  it('returns the end tangent direction at t=1', () => {
+    const out = { x: 0, y: 0 };
+    // P0=(0,0), C=(50,100), P1=(100,0)
+    // B'(1) = 2*(P1-C) = 2*(100-50, 0-100) = (100, -200)
+    getQuadraticBezierTangent(0, 0, 50, 100, 100, 0, 1, out);
+    expect(out.x).toBeCloseTo(100);
+    expect(out.y).toBeCloseTo(-200);
+  });
+
+  it('returns the midpoint tangent at t=0.5', () => {
+    const out = { x: 0, y: 0 };
+    // P0=(0,0), C=(50,100), P1=(100,0)
+    // B'(0.5) = 2*(0.5*(C-P0) + 0.5*(P1-C)) = 2*(0.5*(50,100) + 0.5*(50,-100))
+    //         = 2*((25,50) + (25,-50)) = 2*(50,0) = (100, 0)
+    getQuadraticBezierTangent(0, 0, 50, 100, 100, 0, 0.5, out);
+    expect(out.x).toBeCloseTo(100);
+    expect(out.y).toBeCloseTo(0);
+  });
+
   it('returns the start tangent direction at t=0', () => {
     const out = { x: 0, y: 0 };
     // P0=(0,0), C=(4,0), P1=(8,0) — straight horizontal