@flighthq/node 0.3.0 → 0.3.1-next.1041.35b950c

package/src/revision.test.ts

@@ -1,6 +1,7 @@
 import { createNode, getNodeRuntime } from '@flighthq/node/contract';
 import type { Node, NodeRuntime } from '@flighthq/types/contract';
 
+import { addNodeChild } from './hierarchy';
 import {
   computeNodeWorldTransformRevision,
   getNodeAppearanceRevision,
@@ -41,6 +42,7 @@ describe('computeNodeWorldTransformRevision', () => {
     computeNodeWorldTransformRevision(runtime);
     expect(runtime.worldTransformUsingLocalTransformId).toBe(3);
     expect(runtime.worldTransformUsingParentTransformId).toBe(0);
+    expect(runtime.worldTransformId).not.toBe(0);
   });
 
   it('incorporates parent worldTransformId when provided', () => {
@@ -51,6 +53,17 @@ describe('computeNodeWorldTransformRevision', () => {
     computeNodeWorldTransformRevision(runtime, parentRuntime);
     expect(runtime.worldTransformUsingParentTransformId).toBe(7);
   });
+
+  it('assigns the next monotonic world revision on every recompute', () => {
+    const runtime = getEntityRuntime(node);
+    computeNodeWorldTransformRevision(runtime);
+    const first = runtime.worldTransformId;
+
+    computeNodeWorldTransformRevision(runtime);
+
+    const next = (first + 1) >>> 0;
+    expect(runtime.worldTransformId).toBe(next === 0 ? 1 : next);
+  });
 });
 
 describe('getNodeAppearanceRevision', () => {
@@ -246,6 +259,19 @@ describe('invalidateNodeWorldBounds', () => {
     expect(runtime.worldBoundsUsingWorldTransformId).toBe(-1);
     expect(runtime.worldBoundsUsingLocalBoundsId).toBe(-1);
   });
+
+  it('invalidates every ancestor whose aggregate includes the target', () => {
+    const parent = createTestNode();
+    addNodeChild(parent, node);
+    const parentRuntime = getEntityRuntime(parent);
+    parentRuntime.worldBoundsUsingWorldTransformId = 1;
+    parentRuntime.worldBoundsUsingLocalBoundsId = 1;
+
+    invalidateNodeWorldBounds(node);
+
+    expect(parentRuntime.worldBoundsUsingWorldTransformId).toBe(-1);
+    expect(parentRuntime.worldBoundsUsingLocalBoundsId).toBe(-1);
+  });
 });
 
 type TestNode = Node;

package/src/stageFit.test.ts

@@ -18,10 +18,12 @@ import {
 
 const TestNodeKind = 'TestNode';
 
-function makeNodeWithBounds(width: number, height: number) {
+function makeNodeWithBounds(width: number, height: number, x = 0, y = 0) {
   const node = createNode(TestNodeKind);
   const runtime = getNodeRuntime(node) as unknown as HasBoundsRectangleRuntime;
   runtime.computeLocalBoundsRectangle = (out) => {
+    out.x = x;
+    out.y = y;
     out.width = width;
     out.height = height;
   };
@@ -137,6 +139,18 @@ describe('computeScene2DFitTransform', () => {
     expect(m.d).toBe(1);
   });
 
+  it('sets identity when only the content width is zero', () => {
+    const m = createMatrix(2, 3, 4, 5, 6, 7);
+    computeScene2DFitTransform(m, fit({ root: makeNodeWithBounds(0, 50), scaleMode: 'exactfit' }), 800, 600);
+    expect(m).toMatchObject({ a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 });
+  });
+
+  it('sets identity when only the content height is zero', () => {
+    const m = createMatrix(2, 3, 4, 5, 6, 7);
+    computeScene2DFitTransform(m, fit({ root: makeNodeWithBounds(100, 0), scaleMode: 'exactfit' }), 800, 600);
+    expect(m).toMatchObject({ a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 });
+  });
+
   it('noscale with topleft: identity scale at origin', () => {
     const m = createMatrix();
     computeScene2DFitTransform(
@@ -226,4 +240,45 @@ describe('computeScene2DFitTransform', () => {
     expect(m.b).toBe(0);
     expect(m.c).toBe(0);
   });
+
+  it('maps a nonzero content-bounds origin to the selected alignment', () => {
+    const m = createMatrix();
+    computeScene2DFitTransform(
+      m,
+      fit({ align: 'topleft', root: makeNodeWithBounds(100, 50, 10, -20), scaleMode: 'exactfit' }),
+      200,
+      100,
+    );
+
+    expect(m.a).toBe(2);
+    expect(m.d).toBe(2);
+    expect(m.tx).toBe(-20);
+    expect(m.ty).toBe(40);
+  });
+
+  it('uses scaled width before subtracting a nonzero origin on a centered horizontal axis', () => {
+    const m = createMatrix();
+    computeScene2DFitTransform(
+      m,
+      fit({ align: 'top', root: makeNodeWithBounds(100, 50, 10, -20), scaleMode: 'exactfit' }),
+      200,
+      100,
+    );
+
+    expect(m.tx).toBe(-20);
+    expect(m.ty).toBe(40);
+  });
+
+  it('uses scaled height before subtracting a nonzero origin on a centered vertical axis', () => {
+    const m = createMatrix();
+    computeScene2DFitTransform(
+      m,
+      fit({ align: 'left', root: makeNodeWithBounds(100, 50, 10, -20), scaleMode: 'exactfit' }),
+      200,
+      100,
+    );
+
+    expect(m.tx).toBe(-20);
+    expect(m.ty).toBe(40);
+  });
 });

package/src/traversal.test.ts

@@ -1,8 +1,8 @@
-import type { Node, NodeTraits } from '@flighthq/types/contract';
+import type { Node, NodeRuntime, NodeTraits } from '@flighthq/types/contract';
 import { NodeKind } from '@flighthq/types/contract';
 
 import { addNodeChild } from './hierarchy';
-import { createNode } from './node';
+import { createNode, getNodeRuntime } from './node';
 import {
   findNode,
   findNodeByName,
@@ -190,6 +190,18 @@ describe('getNodeNextSibling', () => {
   it('returns the next sibling', () => {
     expect(getNodeNextSibling(childA)).toBe(childB);
   });
+
+  it('returns null for a stale parent whose child list is absent', () => {
+    (getNodeRuntime(root) as NodeRuntime).children = null;
+
+    expect(getNodeNextSibling(childA)).toBeNull();
+  });
+
+  it('returns null for a stale parent whose nonempty child list omits the source', () => {
+    (getNodeRuntime(root) as NodeRuntime).children = [childB];
+
+    expect(getNodeNextSibling(childA)).toBeNull();
+  });
 });
 
 describe('getNodePreviousSibling', () => {
@@ -204,6 +216,12 @@ describe('getNodePreviousSibling', () => {
   it('returns the previous sibling', () => {
     expect(getNodePreviousSibling(childB)).toBe(childA);
   });
+
+  it('returns null for a stale parent whose child list is absent', () => {
+    (getNodeRuntime(root) as NodeRuntime).children = null;
+
+    expect(getNodePreviousSibling(childB)).toBeNull();
+  });
 });
 
 describe('walkNodeDescendants', () => {
@@ -242,4 +260,16 @@ describe('walkNodeDescendants', () => {
     expect(visited).not.toContain(grandchild);
     expect(visited).not.toContain(childB);
   });
+
+  it('propagates an early stop from a nested descendant', () => {
+    const visited: Node<NodeTraits>[] = [];
+
+    const result = walkNodeDescendants(root, (node) => {
+      visited.push(node);
+      return node !== grandchild;
+    });
+
+    expect(result).toBe(false);
+    expect(visited).toEqual([childA, grandchild]);
+  });
 });