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

package/src/nodeTransform2d.test.ts

@@ -166,6 +166,28 @@ describe('ensureNodeLocalMatrix', () => {
     ensureNodeLocalMatrix(node);
     expect(equalsMatrix(runtime.localMatrix, cache)).toBe(true);
   });
+
+  it('normalizes rotations above 180 degrees', () => {
+    const runtime = getEntityRuntime(node) as HasTransform2DRuntime;
+    node.rotation = 270;
+    invalidateNodeLocalTransform(node);
+
+    ensureNodeLocalMatrix(node);
+
+    expect(runtime.rotationAngle).toBe(-90);
+    expect(runtime.localMatrix?.b).toBeCloseTo(-1);
+  });
+
+  it('normalizes rotations below -180 degrees', () => {
+    const runtime = getEntityRuntime(node) as HasTransform2DRuntime;
+    node.rotation = -270;
+    invalidateNodeLocalTransform(node);
+
+    ensureNodeLocalMatrix(node);
+
+    expect(runtime.rotationAngle).toBe(90);
+    expect(runtime.localMatrix?.b).toBeCloseTo(1);
+  });
 });
 
 describe('ensureNodeWorldMatrix', () => {
@@ -282,6 +304,29 @@ describe('setNodeLocalMatrix', () => {
     expect(m.ty).toBeCloseTo(20);
   });
 
+  // Pins the losslessness this function's contract promises for a reflected (negative determinant)
+  // matrix. Positive-determinant cases round-tripped even while reflected ones silently lost the
+  // reflection, so a fixture that is not reflected cannot speak to this.
+  it('round-trips a reflected matrix, keeping the mirror', () => {
+    setNodeLocalMatrix(node, createMatrix(1, 0, 0, -1, 0, 0));
+    const m = getNodeLocalMatrix(node);
+    expect(m.a).toBeCloseTo(1);
+    expect(m.b).toBeCloseTo(0);
+    expect(m.c).toBeCloseTo(0);
+    expect(m.d).toBeCloseTo(-1);
+  });
+
+  it('round-trips a rotated reflection through all four matrix cells', () => {
+    setNodeLocalMatrix(node, createMatrix(0.5, 0.8, 0.8, -0.5, 3, 4));
+    const m = getNodeLocalMatrix(node);
+    expect(m.a).toBeCloseTo(0.5);
+    expect(m.b).toBeCloseTo(0.8);
+    expect(m.c).toBeCloseTo(0.8);
+    expect(m.d).toBeCloseTo(-0.5);
+    expect(m.tx).toBeCloseTo(3);
+    expect(m.ty).toBeCloseTo(4);
+  });
+
   it('resets pivot and absorbs its offset into translation', () => {
     node.pivotX = 5;
     node.pivotY = 5;

package/src/revision.test.ts

@@ -1,12 +1,15 @@
 import { createNode, getNodeRuntime } from '@flighthq/node/contract';
 import type { Node, NodeRuntime } from '@flighthq/types/contract';
 
+import { addNodeChild } from './hierarchy';
 import {
   computeNodeWorldTransformRevision,
   getNodeAppearanceRevision,
+  getNodeChildrenRevision,
   getNodeLocalBoundsRevision,
   getNodeLocalContentRevision,
   getNodeLocalTransformRevision,
+  getNodeParentReferenceRevision,
   getNodeWorldTransformRevision,
   invalidateContent,
   invalidateNode,
@@ -39,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', () => {
@@ -49,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', () => {
@@ -59,6 +74,14 @@ describe('getNodeAppearanceRevision', () => {
   });
 });
 
+describe('getNodeChildrenRevision', () => {
+  it('returns childrenId', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.childrenId = 100;
+    expect(getNodeChildrenRevision(node)).toStrictEqual(runtime.childrenId);
+  });
+});
+
 describe('getNodeLocalBoundsRevision', () => {
   it('returns localBoundsId', () => {
     const runtime = getEntityRuntime(node);
@@ -83,6 +106,14 @@ describe('getNodeLocalTransformRevision', () => {
   });
 });
 
+describe('getNodeParentReferenceRevision', () => {
+  it('returns parentReferenceId', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.parentReferenceId = 100;
+    expect(getNodeParentReferenceRevision(node)).toStrictEqual(runtime.parentReferenceId);
+  });
+});
+
 describe('getNodeWorldTransformRevision', () => {
   it('returns worldTransformId', () => {
     const runtime = getEntityRuntime(node);
@@ -193,6 +224,13 @@ describe('invalidateNodeLocalTransform', () => {
 });
 
 describe('invalidateNodeParentReference', () => {
+  it('increments parentReferenceId', () => {
+    const runtime = getEntityRuntime(node);
+    const parentReferenceId = runtime.parentReferenceId;
+    invalidateNodeParentReference(node);
+    expect(runtime.parentReferenceId).toBe(parentReferenceId + 1);
+  });
+
   it('invalidates the world transform parent transform cached ID', () => {
     const runtime = getEntityRuntime(node);
     runtime.worldTransformUsingParentTransformId = 1;
@@ -221,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,
@@ -112,7 +112,6 @@ describe('forEachNodeAncestor', () => {
     const visited: Node<NodeTraits>[] = [];
     forEachNodeAncestor(grandchild, (n) => {
       visited.push(n);
-      return true;
     });
     expect(visited).toEqual([childA, root]);
   });
@@ -191,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', () => {
@@ -205,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', () => {
@@ -243,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]);
+  });
 });