@flighthq/node 0.3.1-next.861.5a56d7a → 0.3.1-next.948.85d9f30

package/src/hierarchy.test.ts

@@ -67,6 +67,15 @@ describe('addNodeChild', () => {
     expect(() => addNodeChild(container, container)).toThrow(TypeError);
   });
 
+  it('throws rather than creating a cycle', () => {
+    addNodeChild(container, childA);
+    addNodeChild(childA, childB);
+
+    expect(() => addNodeChild(childB, container)).toThrow(TypeError);
+    expect(getNodeParent(container)).toBeNull();
+    expect(getNodeRoot(childB)).toBe(container);
+  });
+
   it('rejects a child disallowed by the parent runtime', () => {
     getEntityRuntime(container).canAddChild = () => false;
 
@@ -771,27 +780,81 @@ describe('reparentNode', () => {
     expect(after.ty).toBeCloseTo(before.ty, 10);
   });
 
-  it('preserves skewX and skewY values', () => {
+  it('preserves shear induced by rotation across non-uniformly scaled parents', () => {
+    const parentA = createTransformNode();
+    parentA.rotation = -15;
+    parentA.scaleX = 0.75;
+    parentA.scaleY = 2.5;
+    invalidateNodeLocalTransform(parentA);
+
+    const child = createTransformNode();
+    child.x = 10;
+    child.y = 5;
+    child.rotation = 37;
+    child.scaleX = 1.2;
+    child.scaleY = 0.9;
+    invalidateNodeLocalTransform(child);
+    addNodeChild(parentA, child);
+
+    expect(child.skewX).toBe(0);
+    expect(child.skewY).toBe(0);
+    const before = cloneMatrix(getNodeWorldMatrix(child));
+
+    const parentB = createTransformNode();
+    parentB.rotation = 22;
+    parentB.scaleX = 2.4;
+    parentB.scaleY = 0.6;
+    invalidateNodeLocalTransform(parentB);
+
+    reparentNode(child, parentB);
+    const after = getNodeWorldMatrix(child);
+
+    expect(after.a).toBeCloseTo(before.a, 10);
+    expect(after.b).toBeCloseTo(before.b, 10);
+    expect(after.c).toBeCloseTo(before.c, 10);
+    expect(after.d).toBeCloseTo(before.d, 10);
+    expect(after.tx).toBeCloseTo(before.tx, 10);
+    expect(after.ty).toBeCloseTo(before.ty, 10);
+  });
+
+  it('preserves a skewed world transform across asymmetric parents', () => {
     const parentA = createTransformNode();
     parentA.x = 50;
     parentA.rotation = 45;
+    parentA.scaleX = 2;
+    parentA.scaleY = 3;
     invalidateNodeLocalTransform(parentA);
 
     const child = createTransformNode();
     child.x = 10;
+    child.y = 5;
+    child.rotation = 12;
+    child.scaleX = 1.4;
+    child.scaleY = 0.8;
     child.skewX = 15;
     child.skewY = 20;
     invalidateNodeLocalTransform(child);
     addNodeChild(parentA, child);
 
+    const before = cloneMatrix(getNodeWorldMatrix(child));
+
     const parentB = createTransformNode();
     parentB.x = 100;
+    parentB.y = -20;
+    parentB.rotation = -10;
+    parentB.scaleX = 0.7;
+    parentB.scaleY = 1.6;
     invalidateNodeLocalTransform(parentB);
 
     reparentNode(child, parentB);
+    const after = getNodeWorldMatrix(child);
 
-    expect(child.skewX).toBe(15);
-    expect(child.skewY).toBe(20);
+    expect(after.a).toBeCloseTo(before.a, 10);
+    expect(after.b).toBeCloseTo(before.b, 10);
+    expect(after.c).toBeCloseTo(before.c, 10);
+    expect(after.d).toBeCloseTo(before.d, 10);
+    expect(after.tx).toBeCloseTo(before.tx, 10);
+    expect(after.ty).toBeCloseTo(before.ty, 10);
   });
 
   it('preserves world position with pivot', () => {
@@ -873,6 +936,7 @@ describe('reparentNode', () => {
     reparentNode(child, parentB);
     const after = getNodeWorldMatrix(child);
 
+    expect(child.scaleY).toBeLessThan(0);
     expect(after.a).toBeCloseTo(before.a, 10);
     expect(after.b).toBeCloseTo(before.b, 10);
     expect(after.c).toBeCloseTo(before.c, 10);

package/src/nodeOrderList.test.ts

@@ -38,6 +38,12 @@ function getChildren(source: Node) {
   return getNodeRuntime(source).children as Node[];
 }
 
+function expectChildren(source: Node, expected: readonly Node[]): void {
+  const actual = getChildren(source);
+  expect(actual).toHaveLength(expected.length);
+  for (let i = 0; i < expected.length; i++) expect(actual[i]).toBe(expected[i]);
+}
+
 function attachAll() {
   addNodeChild(container, childA);
   addNodeChild(container, childB);
@@ -91,7 +97,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childC, childB, childA]);
+    expectChildren(container, [childC, childB, childA]);
   });
 
   it('never moves a child the list does not name', () => {
@@ -107,7 +113,7 @@ describe('applyNodeOrderList', () => {
 
     // The members swap across the slots they held (0 and 2); the foreign child keeps slot 1, so it
     // still sits between them rather than being compacted to one side.
-    expect(getChildren(container)).toEqual([childB, foreign, childA]);
+    expectChildren(container, [childB, foreign, childA]);
   });
 
   it('ignores entries that are not children of the target', () => {
@@ -121,7 +127,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA]);
+    expectChildren(container, [childB, childA]);
   });
 
   it('ignores entries attached to a different parent', () => {
@@ -136,8 +142,8 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA]);
-    expect(getChildren(other)).toEqual([childC]);
+    expectChildren(container, [childB, childA]);
+    expectChildren(other, [childC]);
   });
 
   it('is a no-op once every member has been removed', () => {
@@ -152,7 +158,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([foreign]);
+    expectChildren(container, [foreign]);
     expect(getNodeChildrenRevision(container)).toBe(revision);
   });
 
@@ -166,7 +172,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childC, childA]);
+    expectChildren(container, [childC, childA]);
   });
 
   it('breaks equal sort keys by the order the entries were added', () => {
@@ -180,7 +186,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childA, childB, childC]);
+    expectChildren(container, [childA, childB, childC]);
   });
 
   it('resolves a node entered twice to its last entry', () => {
@@ -193,7 +199,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA]);
+    expectChildren(container, [childB, childA]);
   });
 
   it('is idempotent', () => {
@@ -207,7 +213,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA]);
+    expectChildren(container, [childB, childA]);
     expect(getNodeChildrenRevision(container)).toBe(revision);
   });
 
@@ -263,9 +269,31 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, createNodeOrderList());
 
-    expect(getChildren(container)).toEqual([childA, childB]);
+    expectChildren(container, [childA, childB]);
     expect(getNodeChildrenRevision(container)).toBe(revision);
   });
+
+  it('leaves a childless target alone when the list is nonempty', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+
+    expect(() => applyNodeOrderList(container, list)).not.toThrow();
+    expect(getNodeRuntime(container).children).toBeNull();
+  });
+
+  it('does not apply retained entries outside the valid window', () => {
+    addNodeChild(container, childC);
+    addNodeChild(container, childB);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childC, 10);
+    addNodeOrderListEntry(list, childB, 0);
+    clearNodeOrderList(list);
+    addNodeOrderListEntry(list, childC, 10);
+
+    applyNodeOrderList(container, list);
+
+    expectChildren(container, [childC, childB]);
+  });
 });
 
 describe('clearNodeOrderList', () => {
@@ -433,7 +461,7 @@ describe('removeNodeOrderListEntry', () => {
 
     // A keeps slot 0 — only its entry was removed, not the child. C was entered before B and stays
     // before it; a swap-with-last removal would have put B first and left the children untouched.
-    expect(getChildren(container)).toEqual([childA, childC, childB]);
+    expectChildren(container, [childA, childC, childB]);
   });
 });
 
@@ -467,7 +495,7 @@ describe('setNodeOrderListEntryAbove', () => {
     setNodeOrderListEntryAbove(list, childA, childC);
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childC, childA]);
+    expectChildren(container, [childB, childC, childA]);
   });
 
   it('places between neighbours whose keys leave no gap', () => {
@@ -477,11 +505,20 @@ describe('setNodeOrderListEntryAbove', () => {
     addNodeOrderListEntry(list, childC, 6);
 
     setNodeOrderListEntryAbove(list, childA, childB);
+
+    expect(list.entryCount).toBe(3);
+    expect(list.nodes).toHaveLength(3);
+    expect(list.sortKeys).toHaveLength(3);
+    expect(list.nodes[0]).toBe(childB);
+    expect(list.nodes[1]).toBe(childA);
+    expect(list.nodes[2]).toBe(childC);
+    expect(list.sortKeys.slice(0, 3)).toEqual([5, 5, 6]);
+
     applyNodeOrderList(container, list);
 
     // No midpoint exists between 5 and 6, so bisection could not express this; the equal-key plus
     // entry-position rule can.
-    expect(getChildren(container)).toEqual([childB, childA, childC]);
+    expectChildren(container, [childB, childA, childC]);
   });
 
   it('moves a node that is already entered rather than duplicating it', () => {
@@ -503,6 +540,16 @@ describe('setNodeOrderListEntryAbove', () => {
     expect(list.entryCount).toBe(0);
   });
 
+  it('keeps an existing node entry when the target has no entry', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 4);
+
+    setNodeOrderListEntryAbove(list, childA, childC);
+
+    expect(list.entryCount).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(4);
+  });
+
   it('does nothing when the node is its own target', () => {
     const list = createNodeOrderList();
     addNodeOrderListEntry(list, childA, 4);
@@ -523,7 +570,7 @@ describe('setNodeOrderListEntryBelow', () => {
     setNodeOrderListEntryBelow(list, childA, childC);
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA, childC]);
+    expectChildren(container, [childB, childA, childC]);
   });
 
   it('places between neighbours whose keys leave no gap', () => {
@@ -535,7 +582,7 @@ describe('setNodeOrderListEntryBelow', () => {
     setNodeOrderListEntryBelow(list, childA, childC);
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA, childC]);
+    expectChildren(container, [childB, childA, childC]);
   });
 
   it('does nothing when the target has no entry', () => {
@@ -545,6 +592,16 @@ describe('setNodeOrderListEntryBelow', () => {
 
     expect(list.entryCount).toBe(0);
   });
+
+  it('keeps an existing node entry when the target has no entry', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 4);
+
+    setNodeOrderListEntryBelow(list, childA, childC);
+
+    expect(list.entryCount).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(4);
+  });
 });
 
 describe('setNodeOrderListFromNodeChildren', () => {
@@ -568,7 +625,7 @@ describe('setNodeOrderListFromNodeChildren', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childA, childB, childC]);
+    expectChildren(container, [childA, childB, childC]);
     expect(getNodeChildrenRevision(container)).toBe(revision);
   });
 
@@ -603,7 +660,7 @@ describe('swapNodeOrderListEntries', () => {
     swapNodeOrderListEntries(list, childA, childC);
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childC, childB, childA]);
+    expectChildren(container, [childC, childB, childA]);
   });
 
   it('does nothing unless both nodes are entered', () => {

package/src/nodeTransform2d.test.ts

@@ -304,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,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

@@ -196,6 +196,12 @@ describe('getNodeNextSibling', () => {
 
     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', () => {