@flighthq/node 0.1.0

package/src/node.test.ts

@@ -0,0 +1,265 @@
+import { connectSignal } from '@flighthq/signals';
+import type { Node, NodeData, NodeRuntime, PartialNode } from '@flighthq/types';
+import { NodeKind } from '@flighthq/types';
+
+import { addNodeChild, getNodeChildCount, getNodeParent } from './hierarchy';
+import {
+  createNode,
+  createNodeRuntime,
+  createNodeSignals,
+  defaultNodeRuntimeCanAddChild,
+  disposeNode,
+  enableNodeSignals,
+  getNodeRuntime,
+  getNodeSignals,
+  setNodeEnabled,
+} from './node';
+
+describe('createNode', () => {
+  let node: Node;
+
+  beforeEach(() => {
+    node = createNode(NodeTestKind);
+  });
+
+  it('initializes default values', () => {
+    expect(node.enabled).toBe(true);
+  });
+
+  it('allows pre-defined values', () => {
+    const base = {
+      parent: createNode(NodeTestKind),
+      children: [],
+      enabled: false,
+    };
+    node = createNode(NodeTestKind, base);
+    expect(node.enabled).toStrictEqual(base.enabled);
+  });
+
+  it('returns a new object for better hidden-class performance', () => {
+    const base = {};
+    node = createNode(NodeTestKind, base);
+    expect(node).not.toStrictEqual(base);
+  });
+
+  it('allows creation of a type without a data field', () => {
+    const node = createNode(NodeTestKind);
+    expect(node.data).toBeNull();
+  });
+
+  it('makes a default runtime object if none passed in', () => {
+    const node = createNode(NodeTestKind);
+    const runtime = getNodeRuntime(node);
+    expect(runtime).not.toBeNull();
+  });
+
+  it('allows a custom type', () => {
+    const node = createNode(NodeTestKind);
+    expect(node.kind).toBe(NodeTestKind);
+  });
+
+  it('returns a new object', () => {
+    const obj: PartialNode<NodeTest> = {};
+    const node: NodeTest = createNode(NodeTestKind, obj) as NodeTest;
+    expect(node).not.toStrictEqual(obj);
+  });
+
+  it('allows use of a data initializer', () => {
+    const obj: PartialNode<NodeTest> = {};
+    const node: NodeTest = createNode(NodeTestKind, obj, createGraphNodeTestData) as NodeTest;
+    expect((node.data as NodeTestData).testDataField).toBe('testDataField');
+  });
+
+  it('allows use of a runtime initializer', () => {
+    const obj: PartialNode<NodeTest> = {};
+    const node = createNode(NodeTestKind, obj, undefined, createGraphNodeTestRuntime);
+    const runtime = getNodeRuntime(node);
+    expect((runtime as NodeTestRuntime).testRuntimeField).toBe('testRuntimeField');
+  });
+});
+
+describe('createNodeRuntime', () => {
+  let runtime: NodeRuntime;
+
+  beforeEach(() => {
+    runtime = createNodeRuntime();
+  });
+
+  it('initializes default values', () => {
+    expect(runtime.appearanceId).toStrictEqual(0);
+    expect(runtime.boundsUsingLocalBoundsId).toStrictEqual(-1);
+    expect(runtime.boundsUsingLocalTransformId).toStrictEqual(-1);
+    expect(runtime.children).toBeNull();
+    expect(runtime.nodeSignals).toBeNull();
+    expect(runtime.localBoundsId).toStrictEqual(0);
+    expect(runtime.localBoundsUsingLocalBoundsId).toStrictEqual(-1);
+    expect(runtime.localTransformId).toStrictEqual(0);
+    expect(runtime.localTransformUsingLocalTransformId).toStrictEqual(-1);
+    expect(runtime.parent).toBeNull();
+    expect(runtime.worldBoundsUsingLocalBoundsId).toStrictEqual(-1);
+    expect(runtime.worldBoundsUsingWorldTransformId).toStrictEqual(-1);
+    expect(runtime.worldTransformId).toStrictEqual(0);
+    expect(runtime.worldTransformUsingLocalTransformId).toStrictEqual(-1);
+    expect(runtime.worldTransformUsingParentTransformId).toStrictEqual(-1);
+    expect(runtime.canAddChild).toStrictEqual(defaultNodeRuntimeCanAddChild);
+  });
+
+  it('does not set traits — concrete graph runtimes set it', () => {
+    expect(runtime.traits).toBeUndefined();
+  });
+
+  it('allows custom canAddChild', () => {
+    const methods = {
+      canAddChild: (_parent: Node, _child: Node) => true,
+    };
+    runtime = createNodeRuntime(methods);
+    expect(runtime.canAddChild).toStrictEqual(methods.canAddChild);
+  });
+});
+
+describe('createNodeSignals', () => {
+  it('returns an object with all signal properties', () => {
+    const signals = createNodeSignals();
+    expect(signals.onChildAdded).toBeDefined();
+    expect(signals.onChildRemoved).toBeDefined();
+    expect(signals.onChildrenChanged).toBeDefined();
+    expect(signals.onChildrenOrderChanged).toBeDefined();
+    expect(signals.onParentChanged).toBeDefined();
+  });
+});
+
+describe('defaultNodeRuntimeCanAddChild', () => {
+  it('always returns true', () => {
+    const parent = createNode(NodeTestKind);
+    const child = createNode(NodeTestKind);
+    expect(defaultNodeRuntimeCanAddChild(parent, child)).toBe(true);
+  });
+});
+
+describe('disposeNode', () => {
+  it('detaches the node from its parent', () => {
+    const parent = createNode(NodeKind);
+    const child = createNode(NodeKind);
+    addNodeChild(parent, child);
+    disposeNode(child);
+    expect(getNodeParent(child)).toBeNull();
+    expect(getNodeChildCount(parent)).toBe(0);
+  });
+
+  it('recursively removes all descendants', () => {
+    const parent = createNode(NodeKind);
+    const child = createNode(NodeKind);
+    const grandchild = createNode(NodeKind);
+    addNodeChild(parent, child);
+    addNodeChild(child, grandchild);
+    disposeNode(parent);
+    expect(getNodeChildCount(parent)).toBe(0);
+    expect(getNodeParent(child)).toBeNull();
+    expect(getNodeParent(grandchild)).toBeNull();
+  });
+
+  it('clears nodeSignals after disposal', () => {
+    const node = createNode(NodeKind);
+    enableNodeSignals(node);
+    disposeNode(node);
+    expect(getNodeSignals(node)).toBeNull();
+  });
+
+  it('is safe to call on a root node with no parent', () => {
+    const node = createNode(NodeKind);
+    expect(() => disposeNode(node)).not.toThrow();
+  });
+
+  it('is safe to call on a leaf node with no children', () => {
+    const node = createNode(NodeKind);
+    expect(() => disposeNode(node)).not.toThrow();
+  });
+});
+
+describe('enableNodeSignals', () => {
+  it('creates and returns signals on first call', () => {
+    const node = createNode(NodeTestKind);
+    const signals = enableNodeSignals(node);
+    expect(signals).toBeDefined();
+    expect(signals.onChildrenChanged).toBeDefined();
+  });
+
+  it('returns the same object on subsequent calls', () => {
+    const node = createNode(NodeTestKind);
+    expect(enableNodeSignals(node)).toBe(enableNodeSignals(node));
+  });
+
+  it('makes getNodeSignals return the enabled object', () => {
+    const node = createNode(NodeTestKind);
+    const signals = enableNodeSignals(node);
+    expect(getNodeSignals(node)).toBe(signals);
+  });
+});
+
+describe('getNodeRuntime', () => {
+  it('assumes runtime is defined', () => {
+    const node = { kind: NodeTestKind };
+    const runtime = getNodeRuntime(node as Node);
+    expect(runtime).toBeUndefined();
+  });
+
+  it('returns runtime when defined', () => {
+    const node = createNode(NodeTestKind);
+    const runtime = getNodeRuntime(node);
+    expect(runtime).not.toBeUndefined();
+  });
+});
+
+describe('getNodeSignals', () => {
+  it('returns null before signals are enabled', () => {
+    const node = createNode(NodeTestKind);
+    expect(getNodeSignals(node)).toBeNull();
+  });
+
+  it('returns the signals after enableNodeSignals', () => {
+    const node = createNode(NodeTestKind);
+    const signals = enableNodeSignals(node);
+    expect(getNodeSignals(node)).toBe(signals);
+  });
+});
+
+describe('setNodeEnabled', () => {
+  it('sets enabled to false', () => {
+    const node = createNode(NodeTestKind);
+    setNodeEnabled(node, false);
+    expect(node.enabled).toBe(false);
+  });
+
+  it('sets enabled back to true', () => {
+    const node = createNode(NodeTestKind);
+    setNodeEnabled(node, false);
+    setNodeEnabled(node, true);
+    expect(node.enabled).toBe(true);
+  });
+});
+
+const NodeTestKind = 'NodeTest';
+
+interface NodeTest extends Node {
+  data: NodeTestData;
+}
+
+interface NodeTestData extends NodeData {
+  testDataField: string;
+}
+
+interface NodeTestRuntime extends NodeRuntime {
+  testRuntimeField: string;
+}
+
+function createGraphNodeTestData(data?: Partial<NodeTestData>): NodeTestData {
+  return {
+    testDataField: data?.testDataField ?? 'testDataField',
+  };
+}
+
+function createGraphNodeTestRuntime(): NodeTestRuntime {
+  const obj = createNodeRuntime() as NodeTestRuntime;
+  obj.testRuntimeField = 'testRuntimeField';
+  return obj;
+}

package/src/revision.test.ts

@@ -0,0 +1,211 @@
+import { createNode, getNodeRuntime } from '@flighthq/node';
+import type { Node, NodeRuntime } from '@flighthq/types';
+
+import {
+  computeNodeWorldTransformRevision,
+  getNodeAppearanceRevision,
+  getNodeLocalBoundsRevision,
+  getNodeLocalContentRevision,
+  getNodeLocalTransformRevision,
+  getNodeWorldTransformRevision,
+  invalidateNode,
+  invalidateNodeAppearance,
+  invalidateNodeLocalBounds,
+  invalidateNodeLocalContent,
+  invalidateNodeLocalTransform,
+  invalidateNodeParentReference,
+  invalidateNodeRender,
+  invalidateNodeWorldBounds,
+} from './revision';
+
+function createTestNode(): TestNode {
+  return createNode(TestKind) as TestNode;
+}
+
+let node: TestNode;
+beforeEach(() => {
+  node = createTestNode();
+});
+
+function getEntityRuntime(source: TestNode) {
+  return getNodeRuntime(source) as NodeRuntime;
+}
+
+describe('computeNodeWorldTransformRevision', () => {
+  it('updates worldTransformId based on local and parent transform IDs', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.localTransformId = 3;
+    computeNodeWorldTransformRevision(runtime);
+    expect(runtime.worldTransformUsingLocalTransformId).toBe(3);
+    expect(runtime.worldTransformUsingParentTransformId).toBe(0);
+  });
+
+  it('incorporates parent worldTransformId when provided', () => {
+    const parentNode = createTestNode();
+    const parentRuntime = getEntityRuntime(parentNode);
+    parentRuntime.worldTransformId = 7;
+    const runtime = getEntityRuntime(node);
+    computeNodeWorldTransformRevision(runtime, parentRuntime);
+    expect(runtime.worldTransformUsingParentTransformId).toBe(7);
+  });
+});
+
+describe('getNodeAppearanceRevision', () => {
+  it('returns appearanceId', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.appearanceId = 100;
+    expect(getNodeAppearanceRevision(node)).toStrictEqual(runtime.appearanceId);
+  });
+});
+
+describe('getNodeLocalBoundsRevision', () => {
+  it('returns localBoundsId', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.localBoundsId = 100;
+    expect(getNodeLocalBoundsRevision(node)).toStrictEqual(runtime.localBoundsId);
+  });
+});
+
+describe('getNodeLocalContentRevision', () => {
+  it('returns localContentId', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.localContentId = 100;
+    expect(getNodeLocalContentRevision(node)).toStrictEqual(runtime.localContentId);
+  });
+});
+
+describe('getNodeLocalTransformRevision', () => {
+  it('returns localTransformId', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.localTransformId = 100;
+    expect(getNodeLocalTransformRevision(node)).toStrictEqual(runtime.localTransformId);
+  });
+});
+
+describe('getNodeWorldTransformRevision', () => {
+  it('returns worldTransformId', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.worldTransformId = 100;
+    expect(getNodeWorldTransformRevision(node)).toStrictEqual(runtime.worldTransformId);
+  });
+});
+
+describe('invalidateNode', () => {
+  it('increments appearanceId, localBoundsId, localContentId, localTransformId', () => {
+    const appearanceId = getEntityRuntime(node).appearanceId;
+    const localBoundsId = getEntityRuntime(node).localBoundsId;
+    const localContentId = getEntityRuntime(node).localContentId;
+    const localTransformId = getEntityRuntime(node).localTransformId;
+    invalidateNode(node);
+    expect(getEntityRuntime(node).appearanceId).toBe(appearanceId + 1);
+    expect(getEntityRuntime(node).localBoundsId).toBe(localBoundsId + 1);
+    expect(getEntityRuntime(node).localContentId).toBe(localContentId + 1);
+    expect(getEntityRuntime(node).localTransformId).toBe(localTransformId + 1);
+  });
+
+  it('invalidates parent reference', () => {
+    invalidateNode(node);
+    expect(getEntityRuntime(node).worldTransformUsingParentTransformId).toBe(-1);
+  });
+
+  it('invalidates world bounds', () => {
+    invalidateNode(node);
+    expect(getEntityRuntime(node).worldBoundsUsingWorldTransformId).toBe(-1);
+    expect(getEntityRuntime(node).worldBoundsUsingLocalBoundsId).toBe(-1);
+  });
+});
+
+describe('invalidateNodeAppearance', () => {
+  it('increments appearanceId', () => {
+    const appearanceId = getEntityRuntime(node).appearanceId;
+    invalidateNodeAppearance(node);
+    expect(getEntityRuntime(node).appearanceId).toBe(appearanceId + 1);
+  });
+
+  it('should wrap around appearanceId correctly using >>> 0', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.appearanceId = 0xffffffff; // max 32-bit uint
+    invalidateNodeAppearance(node);
+    expect(getEntityRuntime(node).appearanceId).toBe(0);
+  });
+});
+
+describe('invalidateNodeLocalBounds', () => {
+  it('increments localBoundsId', () => {
+    const localBoundsId = getEntityRuntime(node).localBoundsId;
+    invalidateNodeLocalBounds(node);
+    expect(getEntityRuntime(node).localBoundsId).toBe(localBoundsId + 1);
+  });
+
+  it('should wrap around localBoundsId correctly using >>> 0', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.localBoundsId = 0xffffffff; // max 32-bit uint
+    invalidateNodeLocalBounds(node);
+    expect(getEntityRuntime(node).localBoundsId).toBe(0);
+  });
+});
+
+describe('invalidateNodeLocalContent', () => {
+  it('increments localContentId', () => {
+    const localContentId = getEntityRuntime(node).localContentId;
+    invalidateNodeLocalContent(node);
+    expect(getEntityRuntime(node).localContentId).toBe(localContentId + 1);
+  });
+
+  it('should wrap around localContentId correctly using >>> 0', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.localContentId = 0xffffffff; // max 32-bit uint
+    invalidateNodeLocalContent(node);
+    expect(getEntityRuntime(node).localContentId).toBe(0);
+  });
+});
+
+describe('invalidateNodeLocalTransform', () => {
+  it('increments localTransformId', () => {
+    const localTransformId = getEntityRuntime(node).localTransformId;
+    invalidateNodeLocalTransform(node);
+    expect(getEntityRuntime(node).localTransformId).toBe(localTransformId + 1);
+  });
+
+  it('should wrap around localTransformId correctly using >>> 0', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.localTransformId = 0xffffffff; // max 32-bit uint
+    invalidateNodeLocalTransform(node);
+    expect(getEntityRuntime(node).localTransformId).toBe(0);
+  });
+});
+
+describe('invalidateNodeParentReference', () => {
+  it('invalidates the world transform parent transform cached ID', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.worldTransformUsingParentTransformId = 1;
+    invalidateNodeParentReference(node);
+    expect(runtime.worldTransformUsingParentTransformId).toBe(-1);
+  });
+});
+
+describe('invalidateNodeRender', () => {
+  it('increments both appearanceId and localTransformId', () => {
+    const runtime = getEntityRuntime(node);
+    const prevAppearance = runtime.appearanceId;
+    const prevLocalTransform = runtime.localTransformId;
+    invalidateNodeRender(node);
+    expect(runtime.appearanceId).toBe(prevAppearance + 1);
+    expect(runtime.localTransformId).toBe(prevLocalTransform + 1);
+  });
+});
+
+describe('invalidateNodeWorldBounds', () => {
+  it('invalidates supporting values for world bounds calculations', () => {
+    const runtime = getEntityRuntime(node);
+    runtime.worldBoundsUsingWorldTransformId = 1;
+    runtime.worldBoundsUsingLocalBoundsId = 1;
+    invalidateNodeWorldBounds(node);
+    expect(runtime.worldBoundsUsingWorldTransformId).toBe(-1);
+    expect(runtime.worldBoundsUsingLocalBoundsId).toBe(-1);
+  });
+});
+
+type TestNode = Node;
+
+const TestKind = 'Test';