@vuer-ai/vuer-rtc 0.0.1

package/tests/operations/vectors.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Tests for vector operations: vector3, quaternion
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createEmptyGraph, applyMessage } from '../../src/index.js';
+import type { SceneGraph, CRDTMessage, Operation } from '../../src/operations/OperationTypes.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface OpFixture {
+  name: string;
+  op: Operation;
+}
+
+function loadOps(filename: string): OpFixture[] {
+  const filepath = join(__dirname, '../fixtures', filename);
+  const content = readFileSync(filepath, 'utf-8');
+  return content
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line));
+}
+
+function createMsg(op: Operation, lamport = 1): CRDTMessage {
+  return {
+    id: `msg-${Math.random().toString(36).slice(2)}`,
+    sessionId: 'test-session',
+    clock: { 'test-session': lamport },
+    lamportTime: lamport,
+    timestamp: Date.now(),
+    ops: [op],
+  };
+}
+
+function createNodeWithProps(
+  graph: SceneGraph,
+  key: string,
+  props: Record<string, unknown>
+): SceneGraph {
+  const nodeOp: Operation = {
+    key: '',
+    otype: 'node.insert',
+    path: 'children',
+    value: {
+      key,
+      id: `uuid-${key}`,
+      tag: 'Mesh',
+      name: key,
+      ...props,
+    },
+  };
+  return applyMessage(graph, createMsg(nodeOp, 0));
+}
+
+describe('Vector3 Operations', () => {
+  let vectorOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    vectorOps = loadOps('vector-ops.jsonl');
+    graph = createEmptyGraph();
+    graph = createNodeWithProps(graph, 'node-1', {
+      position: [0, 0, 0],
+      scale: [1, 1, 1],
+    });
+  });
+
+  it('vector3.set should replace value', () => {
+    const op = vectorOps.find((f) => f.name === 'vector3_set')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].position).toEqual([1, 2, 3]);
+  });
+
+  it('vector3.set to zero should work', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { position: [5, 5, 5] });
+    const op = vectorOps.find((f) => f.name === 'vector3_set_zero')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].position).toEqual([0, 0, 0]);
+  });
+
+  it('vector3.add should add components', () => {
+    const op = vectorOps.find((f) => f.name === 'vector3_add')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].position).toEqual([0.5, 0.5, 0.5]);
+  });
+
+  it('vector3.add with negative should subtract', () => {
+    graph = createNodeWithProps(createEmptyGraph(), 'node-1', { position: [5, 5, 5] });
+    const op = vectorOps.find((f) => f.name === 'vector3_add_negative')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].position).toEqual([4, 4, 4]);
+  });
+
+  it('vector3.multiply should multiply components', () => {
+    const op = vectorOps.find((f) => f.name === 'vector3_multiply')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].scale).toEqual([2, 2, 2]);
+  });
+
+  it('vector3.multiply non-uniform should scale each component', () => {
+    const op = vectorOps.find((f) => f.name === 'vector3_multiply_non_uniform')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].scale).toEqual([1, 2, 3]);
+  });
+
+  it('vector3.add should accumulate multiple operations', () => {
+    const op = vectorOps.find((f) => f.name === 'vector3_add')!.op;
+    let result = applyMessage(graph, createMsg(op, 1));
+    result = applyMessage(result, createMsg(op, 2));
+    result = applyMessage(result, createMsg(op, 3));
+    expect(result.nodes['node-1'].position).toEqual([1.5, 1.5, 1.5]);
+  });
+});
+
+describe('Quaternion Operations', () => {
+  let vectorOps: OpFixture[];
+  let graph: SceneGraph;
+
+  beforeEach(() => {
+    vectorOps = loadOps('vector-ops.jsonl');
+    graph = createEmptyGraph();
+    graph = createNodeWithProps(graph, 'node-1', {
+      rotation: [0, 0, 0, 1], // identity quaternion
+    });
+  });
+
+  it('quaternion.set should replace value', () => {
+    const op = vectorOps.find((f) => f.name === 'quaternion_set')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].rotation).toEqual([0, 0, 0, 1]);
+  });
+
+  it('quaternion.set with rotation should work', () => {
+    const op = vectorOps.find((f) => f.name === 'quaternion_set_rotated')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    expect(result.nodes['node-1'].rotation).toEqual([0, 0.7071, 0, 0.7071]);
+  });
+
+  it('quaternion.multiply should compose rotations', () => {
+    const op = vectorOps.find((f) => f.name === 'quaternion_multiply')!.op;
+    const result = applyMessage(graph, createMsg(op));
+    // Result is the composed rotation
+    expect(result.nodes['node-1'].rotation).toBeDefined();
+    expect(Array.isArray(result.nodes['node-1'].rotation)).toBe(true);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2023", "DOM"],
+    "jsx": "react-jsx",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "noEmit": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*", "tests/**/*"]
+}