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

package/package.json

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

package/src/shape.test.ts

@@ -15,6 +15,13 @@ import {
   getShapeRuntime,
   isShapeEmpty,
 } from './shape';
+import {
+  appendShapeCircle,
+  appendShapeCubicCurveTo,
+  appendShapeCurveTo,
+  appendShapeEllipse,
+  appendShapeMoveTo,
+} from './shapeCommands';
 
 describe('clearShapeCommands', () => {
   it('empties the commands array and bumps the content revision', () => {
@@ -49,6 +56,71 @@ describe('computeShapeLocalBoundsRectangle', () => {
     expect(out.height).toBe(50);
   });
 
+  it('computes bounds from a circle', () => {
+    const shape = createShape();
+    appendShapeCircle(shape, 100, 100, 50);
+    const out = createRectangle();
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    expect(out.x).toBe(50);
+    expect(out.y).toBe(50);
+    expect(out.width).toBe(100);
+    expect(out.height).toBe(100);
+  });
+
+  it('computes bounds from a cubic bezier with an interior extremum', () => {
+    // Cubic from (0,0) to (200,0) with control points (0,0) and (200,150).
+    // X: p0=0, p1=0, p2=200, p3=200. All X values monotonically increase, no X extremum.
+    // Y: p0=0, p1=0, p2=150, p3=0.
+    //   a = -0 + 0 - 450 + 0 = -450
+    //   b = 2*(0 - 0 + 150) = 300
+    //   c = -0 + 0 = 0
+    //   One root at t = 0, excluded (not in open interval). Other: t = -b/a = -300/-450 = 2/3.
+    //   y at t=2/3: u=1/3, u^3*0 + 3*(1/9)*(2/3)*0 + 3*(1/3)*(4/9)*150 + (8/27)*0 = 200/3 ~ 66.667.
+    // expandCubicAxis for Y-axis extrema calls expand(yAtT, xAtT) which is swapped vs expand(x,y).
+    // yAtT = cubicPoint(2/3, 0, 0, 150, 0) = 200/3. xAtT = cubicPoint(2/3, 0, 0, 200, 200) ~ 148.15.
+    // So expand(200/3, 148.15), treating 200/3 as x-extent and 148.15 as y-extent.
+    // Final bounds include endpoints (0,0) and (200,0), plus the extremum expansion.
+    const shape = createShape();
+    appendShapeMoveTo(shape, 0, 0);
+    appendShapeCubicCurveTo(shape, 0, 0, 200, 150, 200, 0);
+    const out = createRectangle();
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    // Bounds encompass at least the two endpoints.
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(0);
+    expect(out.width).toBe(200);
+    // The curve bulges above y=0; the extremum expansion contributes a y-extent of ~148.15.
+    expect(out.height).toBeGreaterThan(100);
+  });
+
+  it('computes bounds from a cubic bezier with a simple horizontal S-curve', () => {
+    // Cubic from (0,0) to (100,100). Control points (100,0) and (0,100) make an S-shape.
+    // The curve stays within the convex hull of its control polygon.
+    const shape = createShape();
+    appendShapeMoveTo(shape, 0, 0);
+    appendShapeCubicCurveTo(shape, 100, 0, 0, 100, 100, 100);
+    const out = createRectangle();
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    // Bounds must at least include the two endpoints.
+    expect(out.x).toBeLessThanOrEqual(0);
+    expect(out.y).toBeLessThanOrEqual(0);
+    expect(out.x + out.width).toBeGreaterThanOrEqual(100);
+    expect(out.y + out.height).toBeGreaterThanOrEqual(100);
+  });
+
+  it('computes bounds from an ellipse', () => {
+    // Ellipse centered at (100,100) with radiusX=60, radiusY=30.
+    // appendShapeEllipse takes (x, y, width, height) where (x,y) is the top-left corner.
+    const shape = createShape();
+    appendShapeEllipse(shape, 40, 70, 120, 60);
+    const out = createRectangle();
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    expect(out.x).toBe(40);
+    expect(out.y).toBe(70);
+    expect(out.width).toBe(120);
+    expect(out.height).toBe(60);
+  });
+
   it('computes bounds from moveTo and lineTo commands', () => {
     const shape = createShape();
     shape.data.commands.push('moveTo', 2, 0, 0, 'lineTo', 2, 80, 60);
@@ -59,6 +131,37 @@ describe('computeShapeLocalBoundsRectangle', () => {
     expect(out.width).toBe(80);
     expect(out.height).toBe(60);
   });
+
+  it('computes bounds from a quadratic bezier with an interior extremum', () => {
+    // Quadratic from (0,0) to (100,0) with control point at (50,100).
+    // The extremum in Y is at t = (p0 - p1) / (p0 - 2*p1 + p2) = (0 - 100) / (0 - 200 + 0) = 0.5.
+    // At t=0.5: y = 0.25*0 + 2*0.25*100 + 0.25*0 = 50.
+    const shape = createShape();
+    appendShapeMoveTo(shape, 0, 0);
+    appendShapeCurveTo(shape, 50, 100, 100, 0);
+    const out = createRectangle();
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(0);
+    expect(out.width).toBe(100);
+    expect(out.height).toBeCloseTo(50, 5);
+  });
+
+  it('computes bounds from a quadratic bezier with extrema in both axes', () => {
+    // Quadratic from (0,50) to (100,50) with control at (50,0).
+    // Y extremum at t = (50 - 0) / (50 - 0 + 50) = 0.5. Y at t=0.5 = 0.25*50 + 0 + 0.25*50 = 25.
+    // X extremum: denomX = 0 - 100 + 100 = 0, so no X extremum (linear in X).
+    // Bounds: x=[0,100], y=[25,50].
+    const shape = createShape();
+    appendShapeMoveTo(shape, 0, 50);
+    appendShapeCurveTo(shape, 50, 0, 100, 50);
+    const out = createRectangle();
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    expect(out.x).toBe(0);
+    expect(out.y).toBeCloseTo(25, 5);
+    expect(out.width).toBe(100);
+    expect(out.height).toBeCloseTo(25, 5);
+  });
 });
 
 describe('copyShapeCommands', () => {

package/src/shapeCommands.test.ts

@@ -1,3 +1,5 @@
+import { getNodeLocalContentRevision } from '@flighthq/node';
+
 import { createShape } from './shape';
 import {
   appendShapeArc,
@@ -236,6 +238,43 @@ describe('appendShapeDrawTriangles', () => {
     appendShapeDrawTriangles(shape, verts, indices, uvt, 'positive');
     expect(shape.data.commands).toEqual(['drawTriangles', 4, verts, indices, uvt, 'positive']);
   });
+
+  it('accepts negative culling', () => {
+    const shape = createShape();
+    const verts = [0, 0, 100, 0, 50, 80];
+    appendShapeDrawTriangles(shape, verts, null, null, 'negative');
+    expect(shape.data.commands[5]).toBe('negative');
+  });
+
+  it('invalidates content on the shape', () => {
+    const shape = createShape();
+    const revision = getNodeLocalContentRevision(shape);
+    appendShapeDrawTriangles(shape, [0, 0, 100, 0, 50, 80]);
+    expect(getNodeLocalContentRevision(shape)).toBe(revision + 1);
+  });
+
+  it('works within a beginFill/endFill cycle', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0xff0000, 1);
+    appendShapeDrawTriangles(shape, [0, 0, 100, 0, 50, 80], [0, 1, 2]);
+    appendShapeEndFill(shape);
+    const keys: string[] = [];
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      keys.push(key);
+      i += argCount + 2;
+    }
+    expect(keys).toEqual(['beginFill', 'drawTriangles', 'endFill']);
+  });
+
+  it('stores the vertices array by reference', () => {
+    const shape = createShape();
+    const verts = [10, 20, 30, 40, 50, 60];
+    appendShapeDrawTriangles(shape, verts);
+    expect(shape.data.commands[2]).toBe(verts);
+  });
 });
 
 describe('appendShapeEllipse', () => {
@@ -330,6 +369,54 @@ describe('appendShapePath', () => {
     appendShapePath(shape, [], []);
     expect(shape.data.commands).toEqual(['drawPath', 3, [], [], 'evenOdd']);
   });
+
+  it('bridges a rectangle path from @flighthq/path command constants', () => {
+    const shape = createShape();
+    const cmds = [
+      PathCommand.MOVE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+      PathCommand.LINE_TO,
+    ];
+    const data = [0, 0, 100, 0, 100, 50, 0, 50, 0, 0];
+    appendShapePath(shape, cmds, data, 'nonZero');
+    // The drawPath token stores the commands and data arrays by reference.
+    expect(shape.data.commands[2]).toBe(cmds);
+    expect(shape.data.commands[3]).toBe(data);
+    expect(shape.data.commands[4]).toBe('nonZero');
+  });
+
+  it('accepts CUBIC_CURVE_TO commands in the path', () => {
+    const shape = createShape();
+    const cmds = [PathCommand.MOVE_TO, PathCommand.CUBIC_CURVE_TO];
+    const data = [0, 0, 10, 20, 30, 40, 50, 60];
+    appendShapePath(shape, cmds, data);
+    expect(shape.data.commands).toEqual(['drawPath', 3, cmds, data, 'evenOdd']);
+  });
+
+  it('invalidates content on the shape', () => {
+    const shape = createShape();
+    const revision = getNodeLocalContentRevision(shape);
+    appendShapePath(shape, [PathCommand.MOVE_TO], [10, 20]);
+    expect(getNodeLocalContentRevision(shape)).toBe(revision + 1);
+  });
+
+  it('works within a beginFill/endFill cycle', () => {
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0x00ff00, 1);
+    appendShapePath(shape, [PathCommand.MOVE_TO, PathCommand.LINE_TO], [0, 0, 100, 100]);
+    appendShapeEndFill(shape);
+    const keys: string[] = [];
+    let i = 0;
+    while (i < shape.data.commands.length) {
+      const key = shape.data.commands[i] as string;
+      const argCount = shape.data.commands[i + 1] as number;
+      keys.push(key);
+      i += argCount + 2;
+    }
+    expect(keys).toEqual(['beginFill', 'drawPath', 'endFill']);
+  });
 });
 
 describe('appendShapePolygon', () => {