@vuer-ai/vuer-rtc-server 0.2.3 → 0.4.1

package/tests/test-data/datatypes.ts

@@ -28,15 +28,15 @@ export const NumberType = {
      */
     set: {
       behavior: 'lww',
-      merge: (ops: Array<{ value: number; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: number; lt: number }>) => {
         // Last-Write-Wins by lamport time
-        const sorted = ops.sort((a, b) => b.lamportTime - a.lamportTime);
+        const sorted = ops.sort((a, b) => b.lt - a.lt);
         return sorted[0].value;
       },
       example: {
         ops: [
-          { value: 42, lamportTime: 100 },
-          { value: 99, lamportTime: 101 },
+          { value: 42, lt: 100 },
+          { value: 99, lt: 101 },
         ],
         result: 99,
       },
@@ -48,14 +48,14 @@ export const NumberType = {
      */
     add: {
       behavior: 'additive',
-      merge: (ops: Array<{ value: number; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: number; lt: number }>) => {
         // Sum all concurrent operations
         return ops.reduce((sum, op) => sum + op.value, 0);
       },
       example: {
         ops: [
-          { value: 10, lamportTime: 100 },
-          { value: 5, lamportTime: 101 },
+          { value: 10, lt: 100 },
+          { value: 5, lt: 101 },
         ],
         result: 15,
       },
@@ -67,13 +67,13 @@ export const NumberType = {
      */
     multiply: {
       behavior: 'multiplicative',
-      merge: (ops: Array<{ value: number; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: number; lt: number }>) => {
         return ops.reduce((product, op) => product * op.value, 1);
       },
       example: {
         ops: [
-          { value: 2, lamportTime: 100 },
-          { value: 3, lamportTime: 101 },
+          { value: 2, lt: 100 },
+          { value: 3, lt: 101 },
         ],
         result: 6,
       },
@@ -85,13 +85,13 @@ export const NumberType = {
      */
     min: {
       behavior: 'min',
-      merge: (ops: Array<{ value: number; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: number; lt: number }>) => {
         return Math.min(...ops.map((op) => op.value));
       },
       example: {
         ops: [
-          { value: 720, lamportTime: 100 },
-          { value: 1080, lamportTime: 101 },
+          { value: 720, lt: 100 },
+          { value: 1080, lt: 101 },
         ],
         result: 720,
       },
@@ -103,13 +103,13 @@ export const NumberType = {
      */
     max: {
       behavior: 'max',
-      merge: (ops: Array<{ value: number; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: number; lt: number }>) => {
         return Math.max(...ops.map((op) => op.value));
       },
       example: {
         ops: [
-          { value: 720, lamportTime: 100 },
-          { value: 1080, lamportTime: 101 },
+          { value: 720, lt: 100 },
+          { value: 1080, lt: 101 },
         ],
         result: 1080,
       },
@@ -132,14 +132,14 @@ export const StringType = {
      */
     set: {
       behavior: 'lww',
-      merge: (ops: Array<{ value: string; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: string; lt: number }>) => {
         const sorted = ops.sort((a, b) => b.lamportTime - a.lamportTime);
         return sorted[0].value;
       },
       example: {
         ops: [
-          { value: 'Cube', lamportTime: 100 },
-          { value: 'Sphere', lamportTime: 101 },
+          { value: 'Cube', lt: 100 },
+          { value: 'Sphere', lt: 101 },
         ],
         result: 'Sphere',
       },
@@ -151,14 +151,14 @@ export const StringType = {
      */
     concat: {
       behavior: 'append',
-      merge: (ops: Array<{ value: string; lamportTime: number }>, separator = '\n') => {
-        const sorted = ops.sort((a, b) => a.lamportTime - b.lamportTime);
+      merge: (ops: Array<{ value: string; lt: number }>, separator = '\n') => {
+        const sorted = ops.sort((a, b) => a.lt - b.lt);
         return sorted.map((op) => op.value).join(separator);
       },
       example: {
         ops: [
-          { value: 'User A edited', lamportTime: 100 },
-          { value: 'User B edited', lamportTime: 101 },
+          { value: 'User A edited', lt: 100 },
+          { value: 'User B edited', lt: 101 },
         ],
         result: 'User A edited\nUser B edited',
       },
@@ -181,14 +181,14 @@ export const BooleanType = {
      */
     set: {
       behavior: 'lww',
-      merge: (ops: Array<{ value: boolean; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: boolean; lt: number }>) => {
         const sorted = ops.sort((a, b) => b.lamportTime - a.lamportTime);
         return sorted[0].value;
       },
       example: {
         ops: [
-          { value: true, lamportTime: 100 },
-          { value: false, lamportTime: 101 },
+          { value: true, lt: 100 },
+          { value: false, lt: 101 },
         ],
         result: false,
       },
@@ -200,13 +200,13 @@ export const BooleanType = {
      */
     or: {
       behavior: 'or',
-      merge: (ops: Array<{ value: boolean; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: boolean; lt: number }>) => {
         return ops.some((op) => op.value === true);
       },
       example: {
         ops: [
-          { value: true, lamportTime: 100 },
-          { value: false, lamportTime: 101 },
+          { value: true, lt: 100 },
+          { value: false, lt: 101 },
         ],
         result: true,
       },
@@ -218,13 +218,13 @@ export const BooleanType = {
      */
     and: {
       behavior: 'and',
-      merge: (ops: Array<{ value: boolean; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: boolean; lt: number }>) => {
         return ops.every((op) => op.value === true);
       },
       example: {
         ops: [
-          { value: true, lamportTime: 100 },
-          { value: false, lamportTime: 101 },
+          { value: true, lt: 100 },
+          { value: false, lt: 101 },
         ],
         result: false,
       },
@@ -253,14 +253,14 @@ export const Vector3Type = {
      */
     set: {
       behavior: 'lww',
-      merge: (ops: Array<{ value: [number, number, number]; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: [number, number, number]; lt: number }>) => {
         const sorted = ops.sort((a, b) => b.lamportTime - a.lamportTime);
         return sorted[0].value;
       },
       example: {
         ops: [
-          { value: [5, 0, 0], lamportTime: 100 },
-          { value: [0, 5, 0], lamportTime: 101 },
+          { value: [5, 0, 0], lt: 100 },
+          { value: [0, 5, 0], lt: 101 },
         ],
         result: [0, 5, 0],
         // NOT [5, 5, 0] - that would violate user intent!
@@ -273,7 +273,7 @@ export const Vector3Type = {
      */
     add: {
       behavior: 'additive',
-      merge: (ops: Array<{ value: [number, number, number]; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: [number, number, number]; lt: number }>) => {
         const sum: [number, number, number] = [0, 0, 0];
         for (const op of ops) {
           sum[0] += op.value[0];
@@ -284,8 +284,8 @@ export const Vector3Type = {
       },
       example: {
         ops: [
-          { value: [1, 0, 0], lamportTime: 100 },
-          { value: [0, 1, 0], lamportTime: 101 },
+          { value: [1, 0, 0], lt: 100 },
+          { value: [0, 1, 0], lt: 101 },
         ],
         result: [1, 1, 0],
       },
@@ -297,7 +297,7 @@ export const Vector3Type = {
      */
     multiply: {
       behavior: 'multiplicative',
-      merge: (ops: Array<{ value: [number, number, number]; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: [number, number, number]; lt: number }>) => {
         const product: [number, number, number] = [1, 1, 1];
         for (const op of ops) {
           product[0] *= op.value[0];
@@ -308,8 +308,8 @@ export const Vector3Type = {
       },
       example: {
         ops: [
-          { value: [2, 1, 1], lamportTime: 100 },
-          { value: [1, 3, 1], lamportTime: 101 },
+          { value: [2, 1, 1], lt: 100 },
+          { value: [1, 3, 1], lt: 101 },
         ],
         result: [2, 3, 1],
       },
@@ -324,24 +324,24 @@ export const Vector3Type = {
       merge: (
         ops: Array<{
           value: Partial<{ x: number; y: number; z: number }>;
-          lamportTime: number;
+          lt: number;
         }>
       ) => {
         const result = { x: 0, y: 0, z: 0 };
         const latest = { x: -1, y: -1, z: -1 };
 
         for (const op of ops) {
-          if (op.value.x !== undefined && op.lamportTime > latest.x) {
+          if (op.value.x !== undefined && op.lt > latest.x) {
             result.x = op.value.x;
-            latest.x = op.lamportTime;
+            latest.x = op.lt;
           }
-          if (op.value.y !== undefined && op.lamportTime > latest.y) {
+          if (op.value.y !== undefined && op.lt > latest.y) {
             result.y = op.value.y;
-            latest.y = op.lamportTime;
+            latest.y = op.lt;
           }
-          if (op.value.z !== undefined && op.lamportTime > latest.z) {
+          if (op.value.z !== undefined && op.lt > latest.z) {
             result.z = op.value.z;
-            latest.z = op.lamportTime;
+            latest.z = op.lt;
           }
         }
 
@@ -349,8 +349,8 @@ export const Vector3Type = {
       },
       example: {
         ops: [
-          { value: { x: 5 }, lamportTime: 100 },
-          { value: { y: 3 }, lamportTime: 101 },
+          { value: { x: 5 }, lt: 100 },
+          { value: { y: 3 }, lt: 101 },
         ],
         result: [5, 3, 0],
       },
@@ -374,14 +374,14 @@ export const QuaternionType = {
      */
     set: {
       behavior: 'lww',
-      merge: (ops: Array<{ value: [number, number, number, number]; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: [number, number, number, number]; lt: number }>) => {
         const sorted = ops.sort((a, b) => b.lamportTime - a.lamportTime);
         return sorted[0].value;
       },
       example: {
         ops: [
-          { value: [0, 0, 0, 1], lamportTime: 100 }, // No rotation
-          { value: [0, 0.707, 0, 0.707], lamportTime: 101 }, // 90° around Y
+          { value: [0, 0, 0, 1], lt: 100 }, // No rotation
+          { value: [0, 0.707, 0, 0.707], lt: 101 }, // 90° around Y
         ],
         result: [0, 0.707, 0, 0.707],
       },
@@ -394,9 +394,9 @@ export const QuaternionType = {
      */
     multiply: {
       behavior: 'multiplicative',
-      merge: (ops: Array<{ value: [number, number, number, number]; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: [number, number, number, number]; lt: number }>) => {
         // Sort by lamport time to get deterministic order
-        const sorted = ops.sort((a, b) => a.lamportTime - b.lamportTime);
+        const sorted = ops.sort((a, b) => a.lt - b.lt);
 
         // Multiply quaternions in order
         let result = sorted[0].value;
@@ -407,8 +407,8 @@ export const QuaternionType = {
       },
       example: {
         ops: [
-          { value: [0, 0.707, 0, 0.707], lamportTime: 100 }, // 90° Y
-          { value: [0.707, 0, 0, 0.707], lamportTime: 101 }, // 90° X
+          { value: [0, 0.707, 0, 0.707], lt: 100 }, // 90° Y
+          { value: [0.707, 0, 0, 0.707], lt: 101 }, // 90° X
         ],
         result: [0.5, 0.5, 0.5, 0.5], // Combined rotation
       },
@@ -449,14 +449,14 @@ export const ColorType = {
      */
     set: {
       behavior: 'lww',
-      merge: (ops: Array<{ value: string; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: string; lt: number }>) => {
         const sorted = ops.sort((a, b) => b.lamportTime - a.lamportTime);
         return sorted[0].value;
       },
       example: {
         ops: [
-          { value: '#ff0000', lamportTime: 100 },
-          { value: '#0000ff', lamportTime: 101 },
+          { value: '#ff0000', lt: 100 },
+          { value: '#0000ff', lt: 101 },
         ],
         result: '#0000ff',
       },
@@ -468,7 +468,7 @@ export const ColorType = {
      */
     blend: {
       behavior: 'blend',
-      merge: (ops: Array<{ value: string; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: string; lt: number }>) => {
         // Convert hex to RGB, average, convert back
         const rgbs = ops.map((op) => hexToRgb(op.value));
         const avgR = Math.round(rgbs.reduce((sum, rgb) => sum + rgb.r, 0) / rgbs.length);
@@ -478,8 +478,8 @@ export const ColorType = {
       },
       example: {
         ops: [
-          { value: '#ff0000', lamportTime: 100 }, // Red
-          { value: '#0000ff', lamportTime: 101 }, // Blue
+          { value: '#ff0000', lt: 100 }, // Red
+          { value: '#0000ff', lt: 101 }, // Blue
         ],
         result: '#7f007f', // Purple
       },
@@ -527,14 +527,14 @@ export const ArrayType = {
      */
     set: {
       behavior: 'lww',
-      merge: (ops: Array<{ value: any[]; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: any[]; lt: number }>) => {
         const sorted = ops.sort((a, b) => b.lamportTime - a.lamportTime);
         return sorted[0].value;
       },
       example: {
         ops: [
-          { value: ['a', 'b'], lamportTime: 100 },
-          { value: ['c', 'd'], lamportTime: 101 },
+          { value: ['a', 'b'], lt: 100 },
+          { value: ['c', 'd'], lt: 101 },
         ],
         result: ['c', 'd'],
       },
@@ -546,14 +546,14 @@ export const ArrayType = {
      */
     union: {
       behavior: 'union',
-      merge: (ops: Array<{ value: any[]; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: any[]; lt: number }>) => {
         const allElements = ops.flatMap((op) => op.value);
         return [...new Set(allElements)];
       },
       example: {
         ops: [
-          { value: ['a', 'b'], lamportTime: 100 },
-          { value: ['b', 'c'], lamportTime: 101 },
+          { value: ['a', 'b'], lt: 100 },
+          { value: ['b', 'c'], lt: 101 },
         ],
         result: ['a', 'b', 'c'],
       },
@@ -565,14 +565,14 @@ export const ArrayType = {
      */
     append: {
       behavior: 'append',
-      merge: (ops: Array<{ value: any[]; lamportTime: number }>) => {
-        const sorted = ops.sort((a, b) => a.lamportTime - b.lamportTime);
+      merge: (ops: Array<{ value: any[]; lt: number }>) => {
+        const sorted = ops.sort((a, b) => a.lt - b.lt);
         return sorted.flatMap((op) => op.value);
       },
       example: {
         ops: [
-          { value: ['edit1'], lamportTime: 100 },
-          { value: ['edit2'], lamportTime: 101 },
+          { value: ['edit1'], lt: 100 },
+          { value: ['edit2'], lt: 101 },
         ],
         result: ['edit1', 'edit2'],
       },
@@ -585,10 +585,10 @@ export const ArrayType = {
     rga: {
       behavior: 'rga',
       merge: (
-        ops: Array<{ action: 'insert' | 'delete'; index: number; value?: any; lamportTime: number }>
+        ops: Array<{ action: 'insert' | 'delete'; index: number; value?: any; lt: number }>
       ) => {
         // Simplified RGA - real implementation needs tombstones and references
-        const sorted = ops.sort((a, b) => a.lamportTime - b.lamportTime);
+        const sorted = ops.sort((a, b) => a.lt - b.lt);
         const result: any[] = [];
 
         for (const op of sorted) {
@@ -603,9 +603,9 @@ export const ArrayType = {
       },
       example: {
         ops: [
-          { action: 'insert', index: 0, value: 'a', lamportTime: 100 },
-          { action: 'insert', index: 1, value: 'b', lamportTime: 101 },
-          { action: 'insert', index: 1, value: 'X', lamportTime: 102 },
+          { action: 'insert', index: 0, value: 'a', lt: 100 },
+          { action: 'insert', index: 1, value: 'b', lt: 101 },
+          { action: 'insert', index: 1, value: 'X', lt: 102 },
         ],
         result: ['a', 'X', 'b'],
       },
@@ -628,14 +628,14 @@ export const ObjectType = {
      */
     set: {
       behavior: 'lww',
-      merge: (ops: Array<{ value: Record<string, any>; lamportTime: number }>) => {
+      merge: (ops: Array<{ value: Record<string, any>; lt: number }>) => {
         const sorted = ops.sort((a, b) => b.lamportTime - a.lamportTime);
         return sorted[0].value;
       },
       example: {
         ops: [
-          { value: { a: 1 }, lamportTime: 100 },
-          { value: { b: 2 }, lamportTime: 101 },
+          { value: { a: 1 }, lt: 100 },
+          { value: { b: 2 }, lt: 101 },
         ],
         result: { b: 2 },
       },
@@ -648,14 +648,14 @@ export const ObjectType = {
     lwwPerKey: {
       behavior: 'lww-per-key',
       merge: (
-        ops: Array<{ value: Record<string, any>; lamportTime: number; perKeyLamport?: Record<string, number> }>
+        ops: Array<{ value: Record<string, any>; lt: number; perKeyLamport?: Record<string, number> }>
       ) => {
         const result: Record<string, any> = {};
         const latestTimes: Record<string, number> = {};
 
         for (const op of ops) {
           for (const [key, value] of Object.entries(op.value)) {
-            const keyLamport = op.perKeyLamport?.[key] ?? op.lamportTime;
+            const keyLamport = op.perKeyLamport?.[key] ?? op.lt;
             if (!latestTimes[key] || keyLamport > latestTimes[key]) {
               result[key] = value;
               latestTimes[key] = keyLamport;
@@ -667,8 +667,8 @@ export const ObjectType = {
       },
       example: {
         ops: [
-          { value: { color: 'red', size: 10 }, lamportTime: 100 },
-          { value: { color: 'blue', opacity: 0.5 }, lamportTime: 101 },
+          { value: { color: 'red', size: 10 }, lt: 100 },
+          { value: { color: 'blue', opacity: 0.5 }, lt: 101 },
         ],
         result: { color: 'blue', size: 10, opacity: 0.5 },
       },