@flighthq/node 0.1.0

package/src/hasTransform2d.test.ts

@@ -0,0 +1,67 @@
+import type { HasTransform2D, HasTransform2DRuntime, Node, NodeRuntime } from '@flighthq/types';
+
+import { initTransform2DRuntimeTrait, initTransform2DTrait } from './hasTransform2d';
+import { createNode, createNodeRuntime } from './node';
+
+describe('initTransform2DRuntimeTrait', () => {
+  let runtime: NodeRuntime<HasTransform2D> & HasTransform2DRuntime;
+
+  beforeEach(() => {
+    runtime = createNodeRuntime() as NodeRuntime<HasTransform2D> & HasTransform2DRuntime;
+  });
+
+  it('initializes default values', () => {
+    initTransform2DRuntimeTrait(runtime);
+
+    expect(runtime.localTransform2D).toBeNull();
+    expect(runtime.rotationAngle).toStrictEqual(0);
+    expect(runtime.rotationCosine).toStrictEqual(1);
+    expect(runtime.rotationSine).toStrictEqual(0);
+    expect(runtime.worldTransform2D).toBeNull();
+
+    // inherited graph runtime fields
+    expect(runtime.appearanceId).toStrictEqual(0);
+  });
+});
+
+describe('initTransform2DTrait', () => {
+  let node: HasTransform2D;
+
+  beforeEach(() => {
+    node = createNode(NodeTestKind) as Node<HasTransform2D> & HasTransform2D;
+  });
+
+  it('initializes default values', () => {
+    initTransform2DTrait(node);
+
+    expect(node.rotation).toStrictEqual(0);
+    expect(node.scaleX).toStrictEqual(1);
+    expect(node.scaleY).toStrictEqual(1);
+    expect(node.skewX).toStrictEqual(0);
+    expect(node.skewY).toStrictEqual(0);
+    expect(node.x).toStrictEqual(0);
+    expect(node.y).toStrictEqual(0);
+  });
+
+  it('allows pre-defined values', () => {
+    const base = {
+      scaleX: 2,
+      scaleY: 3,
+      skewX: 15,
+      skewY: 30,
+      rotation: 45,
+      x: 100,
+      y: 200,
+    };
+    initTransform2DTrait(node, base);
+    expect(node.scaleX).toStrictEqual(base.scaleX);
+    expect(node.scaleY).toStrictEqual(base.scaleY);
+    expect(node.skewX).toStrictEqual(base.skewX);
+    expect(node.skewY).toStrictEqual(base.skewY);
+    expect(node.rotation).toStrictEqual(base.rotation);
+    expect(node.x).toStrictEqual(base.x);
+    expect(node.y).toStrictEqual(base.y);
+  });
+});
+
+const NodeTestKind = 'NodeTest';

package/src/hasTransform3d.test.ts

@@ -0,0 +1,37 @@
+import type { HasTransform3D, HasTransform3DRuntime, Matrix4 } from '@flighthq/types';
+import { describe, expect, it } from 'vitest';
+
+import { initTransform3DRuntimeTrait, initTransform3DTrait } from './hasTransform3d';
+
+describe('initTransform3DRuntimeTrait', () => {
+  it('sets worldMatrix to null', () => {
+    const runtime = {} as HasTransform3DRuntime;
+    initTransform3DRuntimeTrait(runtime);
+    expect(runtime.worldMatrix).toBeNull();
+  });
+});
+
+describe('initTransform3DTrait', () => {
+  it('creates an identity localMatrix by default', () => {
+    const node = {} as HasTransform3D;
+    initTransform3DTrait(node);
+    expect(node.localMatrix).toBeDefined();
+    const m = node.localMatrix.m;
+    expect(m[0]).toBe(1);
+    expect(m[5]).toBe(1);
+    expect(m[10]).toBe(1);
+    expect(m[15]).toBe(1);
+    expect(m[12]).toBe(0);
+    expect(m[13]).toBe(0);
+    expect(m[14]).toBe(0);
+  });
+
+  it('accepts an existing localMatrix', () => {
+    const node = {} as HasTransform3D;
+    const existing = { m: new Float32Array(16) } as unknown as Matrix4;
+    existing.m[12] = 7;
+    initTransform3DTrait(node, { localMatrix: existing });
+    expect(node.localMatrix).toBe(existing);
+    expect(node.localMatrix.m[12]).toBe(7);
+  });
+});