@flighthq/snapshot 0.2.0 → 0.2.1-next.410.a23f189

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/snapshot",
-  "version": "0.2.0",
+  "version": "0.2.1-next.410.a23f189",
   "repository": {
     "type": "git",
     "url": "https://github.com/flighthq/flight.git",
@@ -32,8 +32,8 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/math": "0.2.0",
-    "@flighthq/types": "0.2.0"
+    "@flighthq/math": "0.2.1-next.410.a23f189",
+    "@flighthq/types": "0.2.1-next.410.a23f189"
   },
   "devDependencies": {
     "typescript": "^5.3.0"

package/src/equalsSnapshot.test.ts

@@ -32,6 +32,24 @@ describe('equalsSnapshot', () => {
     expect(equalsSnapshot(captureSnapshot({}), captureSnapshot({}))).toBe(true);
   });
 
+  it('is false for an array compared to an object with the same indexed values', () => {
+    const a = captureSnapshot([1, 2] as unknown as object);
+    const b = captureSnapshot({ 0: 1, 1: 2 } as unknown as object);
+    expect(equalsSnapshot(a, b)).toBe(false);
+  });
+
+  it('is false when objects differ three levels deep', () => {
+    const a = captureSnapshot({ level1: { level2: { level3: { value: 1 } } } });
+    const b = captureSnapshot({ level1: { level2: { level3: { value: 2 } } } });
+    expect(equalsSnapshot(a, b)).toBe(false);
+  });
+
+  it('is true when objects are equal three levels deep', () => {
+    const a = captureSnapshot({ level1: { level2: { level3: { value: 42 } } } });
+    const b = captureSnapshot({ level1: { level2: { level3: { value: 42 } } } });
+    expect(equalsSnapshot(a, b)).toBe(true);
+  });
+
   it('distinguishes null from a value at the same key', () => {
     const a = captureSnapshot({ tag: null as number | null });
     const b = captureSnapshot({ tag: 0 as number | null });

package/src/interpolateSnapshots.test.ts

@@ -23,6 +23,16 @@ describe('interpolateSnapshots', () => {
     expect(atEnd).toEqual({ x: 10, y: 0 });
   });
 
+  it('interpolates only dotted-path schema-listed nested fields', () => {
+    const a = captureSnapshot({ pos: { x: 0, y: 0 }, hp: 100 });
+    const b = captureSnapshot({ pos: { x: 100, y: 200 }, hp: 0 });
+    const out = { pos: { x: 0, y: 0 }, hp: 0 };
+    interpolateSnapshots(a, b, 0.5, out, ['pos.x']);
+    expect(out.pos.x).toBe(50);
+    expect(out.pos.y).toBe(200);
+    expect(out.hp).toBe(0);
+  });
+
   it('interpolates only schema-listed paths and snaps the rest to b', () => {
     const a = captureSnapshot({ x: 0, y: 10 });
     const b = captureSnapshot({ x: 10, y: 0 });
@@ -39,6 +49,16 @@ describe('interpolateSnapshots', () => {
     expect(out.pos).toEqual({ x: 25, y: 10 });
   });
 
+  it('assigns keys present only in b and ignores keys present only in a', () => {
+    const a = captureSnapshot({ x: 10, onlyA: 99 } as Record<string, unknown>);
+    const b = captureSnapshot({ x: 20, onlyB: 'hello' } as Record<string, unknown>);
+    const out = { x: 0 } as Record<string, unknown>;
+    interpolateSnapshots(a, b, 0.5, out);
+    expect(out.x).toBe(15);
+    expect(out.onlyB).toBe('hello');
+    expect(out).not.toHaveProperty('onlyA');
+  });
+
   it('clamps t below 0 and above 1', () => {
     const a = captureSnapshot({ x: 0 });
     const b = captureSnapshot({ x: 10 });
@@ -58,6 +78,14 @@ describe('interpolateSnapshots', () => {
     expect(out.points).toEqual([5, 50]);
   });
 
+  it('snaps to b when a has a number but b has a non-number at the same key', () => {
+    const a = captureSnapshot({ x: 5 } as Record<string, unknown>);
+    const b = captureSnapshot({ x: 'hello' } as Record<string, unknown>);
+    const out = { x: 0 } as Record<string, unknown>;
+    interpolateSnapshots(a, b, 0.5, out);
+    expect(out.x).toBe('hello');
+  });
+
   it('snaps a null field to b', () => {
     const a = captureSnapshot({ value: 1, tag: null as number | null });
     const b = captureSnapshot({ value: 3, tag: null as number | null });

package/src/restoreSnapshot.test.ts

@@ -19,6 +19,13 @@ describe('restoreSnapshot', () => {
     expect(target.items).toEqual([1, 2, 3]);
   });
 
+  it('is a no-op for a primitive top-level snapshot', () => {
+    const snapshot = captureSnapshot(42 as unknown as Record<string, unknown>);
+    const target: Record<string, unknown> = { x: 1 };
+    restoreSnapshot(snapshot, target);
+    expect(target).toEqual({ x: 1 });
+  });
+
   it('keeps the target object identity, mutating in place', () => {
     const snapshot = captureSnapshot({ x: 1 });
     const target = { x: 0 };
@@ -45,6 +52,31 @@ describe('restoreSnapshot', () => {
     expect(snapshot.nested.a).toBe(1);
   });
 
+  it('preserves extra keys in the target that are not in the snapshot', () => {
+    const snapshot = captureSnapshot({ x: 10 } as Record<string, number>);
+    const target = { x: 0, y: 5, z: 99 } as Record<string, number>;
+    restoreSnapshot(snapshot, target);
+    expect(target.x).toBe(10);
+    expect(target.y).toBe(5);
+    expect(target.z).toBe(99);
+  });
+
+  it('replaces a nested container when the type changes from object to array', () => {
+    const snapshot = captureSnapshot({ data: [1, 2, 3] as unknown });
+    const target = { data: { a: 1 } as unknown };
+    restoreSnapshot(snapshot, target);
+    expect(target.data).toEqual([1, 2, 3]);
+    expect(Array.isArray(target.data)).toBe(true);
+  });
+
+  it('replaces a nested container when the type changes from array to object', () => {
+    const snapshot = captureSnapshot({ data: { a: 1 } as unknown });
+    const target = { data: [1, 2, 3] as unknown };
+    restoreSnapshot(snapshot, target);
+    expect(target.data).toEqual({ a: 1 });
+    expect(Array.isArray(target.data)).toBe(false);
+  });
+
   it('resizes the target array to the snapshot array length', () => {
     const snapshot = captureSnapshot({ items: [1, 2] });
     const target = { items: [9, 9, 9, 9] };