@flighthq/path 0.5.0-next.1944.cd6b6e7 → 0.5.1-edge.638.d4dbd4e

package/README.md

@@ -13,5 +13,5 @@ Import the supported application-facing API from `@flighthq/path`. The `@flighth
 This package is part of the locked-version Flight SDK graph. Applications may instead install and import `@flighthq/sdk` when package-level tree shaking is sufficient.
 
 - [Flight project](https://github.com/flighthq/flight)
-- [Source for @flighthq/path@0.5.0-next.1944.cd6b6e7](https://github.com/flighthq/flight/tree/cd6b6e71eb472b3a4249830a7743333f019fa7b7/packages/path)
-- [License](https://github.com/flighthq/flight/blob/cd6b6e71eb472b3a4249830a7743333f019fa7b7/LICENSE.md)
+- [Source for @flighthq/path@0.5.1-edge.638.d4dbd4e](https://github.com/flighthq/flight/tree/d4dbd4e347dc8be10b180c85a766ab50333dcb51/packages/path)
+- [License](https://github.com/flighthq/flight/blob/d4dbd4e347dc8be10b180c85a766ab50333dcb51/LICENSE.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/path",
-  "version": "0.5.0-next.1944.cd6b6e7",
+  "version": "0.5.1-edge.638.d4dbd4e",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -38,8 +38,8 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/math": "0.5.0-next.1944.cd6b6e7",
-    "@flighthq/types": "0.5.0-next.1944.cd6b6e7"
+    "@flighthq/math": "0.5.1-edge.638.d4dbd4e",
+    "@flighthq/types": "0.5.1-edge.638.d4dbd4e"
   },
   "devDependencies": {
     "typescript": "^5.3.0"

package/src/tessellateStrokePath.test.ts

@@ -1,3 +1,5 @@
+import type { StrokeStyle } from '@flighthq/types/contract';
+
 import { appendPathClose, appendPathLineTo, appendPathMoveTo, appendPathRectangle, createPath } from './path';
 import { tessellateStrokePath } from './tessellateStrokePath';
 
@@ -63,6 +65,81 @@ describe('tessellateStrokePath', () => {
     expect(tessellateStrokePath(path, { width: 0 })).toBeNull();
     expect(tessellateStrokePath(path, { width: Number.NaN })).toBeNull();
   });
+
+  // The sharing contract on StrokeTessellator, which exists because a derived render pipeline
+  // INHERITS the tessellator bound to its source — one function object serves every state in that
+  // lineage. Each probe below asserts a property nothing else in this suite covers.
+  //
+  // Every one of them is grounded in a mesh asserted NONEMPTY first. A degenerate path returns an
+  // empty mesh, and against an empty mesh all four probes pass while proving nothing: two empty
+  // results always match, always have distinct empty arrays, and never disturb each other.
+
+  it('returns a nonempty mesh for the fixtures the sharing probes rely on', () => {
+    expect(tessellateStrokePath(makeOpenPath(), OPEN_STYLE)!.vertices.length).toBeGreaterThan(0);
+    expect(tessellateStrokePath(makeClosedPath(), CLOSED_STYLE, 0.1)!.vertices.length).toBeGreaterThan(0);
+  });
+
+  it('returns identical geometry when calls for two paths are interleaved', () => {
+    const openBaseline = JSON.stringify(tessellateStrokePath(makeOpenPath(), OPEN_STYLE));
+    const closedBaseline = JSON.stringify(tessellateStrokePath(makeClosedPath(), CLOSED_STYLE, 0.1));
+    let drifted = 0;
+    for (let i = 0; i < 50; i++) {
+      if (JSON.stringify(tessellateStrokePath(makeOpenPath(), OPEN_STYLE)) !== openBaseline) drifted++;
+      if (JSON.stringify(tessellateStrokePath(makeClosedPath(), CLOSED_STYLE, 0.1)) !== closedBaseline) drifted++;
+    }
+    expect(drifted).toBe(0);
+  });
+
+  it('allocates fresh result arrays for every call', () => {
+    const first = tessellateStrokePath(makeOpenPath(), OPEN_STYLE)!;
+    const second = tessellateStrokePath(makeOpenPath(), OPEN_STYLE)!;
+    expect(first.vertices).not.toBe(second.vertices);
+    expect(first.indices).not.toBe(second.indices);
+  });
+
+  it('is unaffected by a caller mutating an earlier result', () => {
+    const baseline = JSON.stringify(tessellateStrokePath(makeOpenPath(), OPEN_STYLE));
+    const owned = tessellateStrokePath(makeOpenPath(), OPEN_STYLE)!;
+    owned.vertices.length = 0;
+    owned.indices.push(999_999);
+    expect(JSON.stringify(tessellateStrokePath(makeOpenPath(), OPEN_STYLE))).toBe(baseline);
+  });
+
+  it('is reentrant when a nested call runs inside an in-progress one', () => {
+    const openBaseline = JSON.stringify(tessellateStrokePath(makeOpenPath(), OPEN_STYLE));
+    const closedBaseline = JSON.stringify(tessellateStrokePath(makeClosedPath(), CLOSED_STYLE, 0.1));
+    let nestedRan = false;
+    let nestedMatched = false;
+    // Reading `width` mid-tessellation triggers the inner call, so the two are genuinely interleaved
+    // rather than merely sequential.
+    const reentrantStyle = new Proxy(
+      { ...OPEN_STYLE },
+      {
+        get(target, key) {
+          if (key === 'width' && !nestedRan) {
+            nestedRan = true;
+            nestedMatched =
+              JSON.stringify(tessellateStrokePath(makeClosedPath(), CLOSED_STYLE, 0.1)) === closedBaseline;
+          }
+          return (target as Record<string | symbol, unknown>)[key];
+        },
+      },
+    ) as StrokeStyle;
+    const outer = JSON.stringify(tessellateStrokePath(makeOpenPath(), reentrantStyle));
+    expect(nestedRan).toBe(true);
+    expect(nestedMatched).toBe(true);
+    expect(outer).toBe(openBaseline);
+  });
+
+  it('does not mutate the path or style it is given', () => {
+    const path = makeOpenPath();
+    const style = { ...OPEN_STYLE };
+    const pathBefore = JSON.stringify(path);
+    const styleBefore = JSON.stringify(style);
+    tessellateStrokePath(path, style);
+    expect(JSON.stringify(path)).toBe(pathBefore);
+    expect(JSON.stringify(style)).toBe(styleBefore);
+  });
 });
 
 function bowTie() {
@@ -89,3 +166,22 @@ function getMeshArea(mesh: { indices: readonly number[]; vertices: readonly numb
   }
   return area;
 }
+
+// Fixtures for the sharing-contract probes: one open polyline and one closed ring, both chosen because
+// they produce real geometry (12 and 80 vertices).
+const OPEN_STYLE: StrokeStyle = { cap: 'butt', join: 'miter', width: 10 };
+const CLOSED_STYLE: StrokeStyle = { join: 'round', width: 7 };
+
+function makeOpenPath(): ReturnType<typeof createPath> {
+  const path = createPath();
+  appendPathMoveTo(path, 0, 0);
+  appendPathLineTo(path, 100, 0);
+  appendPathLineTo(path, 100, 100);
+  return path;
+}
+
+function makeClosedPath(): ReturnType<typeof createPath> {
+  const path = createPath();
+  appendPathRectangle(path, 0, 0, 100, 50);
+  return path;
+}