pixelweaver 0.1.0

package/src/lib/animation/animation-commands.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PixelBuffer } from '../canvas/pixel-buffer.js';
+import { dispatch, undoLast, redoLast, _resetForTesting as resetDispatcher } from '../core/dispatcher.js';
+import { createPluginAPI } from '../core/plugin-api.js';
+import { layerCommandsPlugin } from '../layers/layer-commands.js';
+import { animationCommandsPlugin } from './animation-commands.js';
+import * as tree from '../layers/layer-tree.svelte.js';
+import * as fm from './frame-model.svelte.js';
+import * as ft from './frame-tags.svelte.js';
+import type { Command } from '../core/commands.js';
+import type { CommandType, ParamsOf } from '../core/command-params.js';
+
+// --- Helpers ---
+
+// Typed overload: validates params when type is a known command literal
+function makeCommand<T extends CommandType>(type: T, params: ParamsOf<T>): Command;
+// String fallback: for dynamic/unknown command types in tests
+function makeCommand(type: string, params?: Record<string, unknown>): Command;
+function makeCommand(type: string, params: Record<string, unknown> = {}): Command {
+  return {
+    type,
+    plugin: 'builtin/animation',
+    version: '1.0.0',
+    params,
+    timestamp: Date.now(),
+    id: crypto.randomUUID(),
+  };
+}
+
+// --- Setup ---
+
+beforeEach(() => {
+  tree._resetForTesting();
+  fm._resetForTesting();
+  ft._resetForTesting();
+  resetDispatcher();
+
+  // Register dependencies first, then animation commands
+  const layerApi = createPluginAPI('builtin/layers');
+  layerCommandsPlugin.register(layerApi);
+  const animApi = createPluginAPI('builtin/animation');
+  animationCommandsPlugin.register(animApi);
+
+  // Seed with one frame so operations work
+  fm.addFrame();
+});
+
+// --- Tests ---
+
+describe('add_frame command', () => {
+  it('should add a frame', () => {
+    dispatch(makeCommand('add_frame', {}));
+    expect(fm.getFrames()).toHaveLength(2);
+  });
+
+  it('should undo by removing the added frame', () => {
+    dispatch(makeCommand('add_frame', {}));
+    expect(fm.getFrames()).toHaveLength(2);
+    undoLast();
+    expect(fm.getFrames()).toHaveLength(1);
+  });
+});
+
+describe('remove_frame command', () => {
+  it('should remove a frame', () => {
+    fm.addFrame(); // now 2 frames
+    dispatch(makeCommand('remove_frame', { index: 0 }));
+    expect(fm.getFrames()).toHaveLength(1);
+  });
+
+  it('should undo by restoring the removed frame', () => {
+    const frame = fm.addFrame(); // now 2 frames
+    const buf = new PixelBuffer(4, 4);
+    buf.setPixel(0, 0, 42, 0, 0, 255);
+    frame.pixelData.set('test-layer', buf);
+
+    dispatch(makeCommand('remove_frame', { index: 1 }));
+    expect(fm.getFrames()).toHaveLength(1);
+
+    undoLast();
+    expect(fm.getFrames()).toHaveLength(2);
+    // Pixel data should be restored
+    const restored = fm.getFrames()[1]?.pixelData.get('test-layer');
+    expect(restored).toBeDefined();
+    expect(restored?.getPixel(0, 0)).toEqual([42, 0, 0, 255]);
+  });
+});
+
+describe('duplicate_frame command', () => {
+  it('should duplicate a frame', () => {
+    dispatch(makeCommand('duplicate_frame', { index: 0 }));
+    expect(fm.getFrames()).toHaveLength(2);
+  });
+
+  it('should undo by removing the duplicate', () => {
+    dispatch(makeCommand('duplicate_frame', { index: 0 }));
+    expect(fm.getFrames()).toHaveLength(2);
+    undoLast();
+    expect(fm.getFrames()).toHaveLength(1);
+  });
+});
+
+describe('reorder_frame command', () => {
+  it('should reorder frames and undo', () => {
+    fm.addFrame(); // now 2 frames
+    const id0 = fm.getFrames()[0]?.id;
+    const id1 = fm.getFrames()[1]?.id;
+
+    dispatch(makeCommand('reorder_frame', { fromIndex: 0, toIndex: 1 }));
+    expect(fm.getFrames()[0]?.id).toBe(id1);
+    expect(fm.getFrames()[1]?.id).toBe(id0);
+
+    undoLast();
+    expect(fm.getFrames()[0]?.id).toBe(id0);
+    expect(fm.getFrames()[1]?.id).toBe(id1);
+  });
+});
+
+describe('reorder_frames command', () => {
+  it('should reorder multiple frames via command', () => {
+    fm.addFrame(); // now 2 frames
+    fm.addFrame(); // now 3
+    fm.addFrame(); // now 4 (indices 0-3)
+    const id0 = fm.getFrames()[0]?.id;
+    const id1 = fm.getFrames()[1]?.id;
+    const id2 = fm.getFrames()[2]?.id;
+    const id3 = fm.getFrames()[3]?.id;
+
+    // Move frames [0,1] to position 3
+    dispatch(makeCommand('reorder_frames', { fromIndices: [0, 1], toIndex: 3 }));
+    const ids = fm.getFrames().map((f) => f.id);
+    // sorted=[0,1], extracted=[id0,id1], remaining=[id2,id3]
+    // adjustedTarget = 3 - 2 = 1
+    // splice(1, 0, id0, id1) => [id2, id0, id1, id3]
+    expect(ids).toEqual([id2, id0, id1, id3]);
+  });
+
+  it('should undo to restore original order', () => {
+    fm.addFrame();
+    fm.addFrame();
+    fm.addFrame(); // 4 frames total
+    const originalIds = fm.getFrames().map((f) => f.id);
+
+    dispatch(makeCommand('reorder_frames', { fromIndices: [0, 1], toIndex: 3 }));
+    // Verify order changed
+    expect(fm.getFrames().map((f) => f.id)).not.toEqual(originalIds);
+
+    undoLast();
+    expect(fm.getFrames().map((f) => f.id)).toEqual(originalIds);
+  });
+
+  it('should redo to re-apply the reorder', () => {
+    fm.addFrame();
+    fm.addFrame();
+    fm.addFrame(); // 4 frames total
+    const originalIds = fm.getFrames().map((f) => f.id);
+
+    dispatch(makeCommand('reorder_frames', { fromIndices: [0, 1], toIndex: 3 }));
+    const reorderedIds = fm.getFrames().map((f) => f.id);
+
+    undoLast();
+    expect(fm.getFrames().map((f) => f.id)).toEqual(originalIds);
+
+    redoLast();
+    expect(fm.getFrames().map((f) => f.id)).toEqual(reorderedIds);
+  });
+});
+
+describe('set_frame_duration command', () => {
+  it('should change frame duration', () => {
+    dispatch(makeCommand('set_frame_duration', { index: 0, durationMs: 200 }));
+    expect(fm.getFrames()[0]?.durationMs).toBe(200);
+  });
+
+  it('should undo to restore old duration', () => {
+    dispatch(makeCommand('set_frame_duration', { index: 0, durationMs: 200 }));
+    undoLast();
+    expect(fm.getFrames()[0]?.durationMs).toBeNull();
+  });
+});
+
+describe('set_global_fps command', () => {
+  it('should change global FPS and undo', () => {
+    dispatch(makeCommand('set_global_fps', { fps: 24 }));
+    expect(fm.getGlobalFps()).toBe(24);
+
+    undoLast();
+    expect(fm.getGlobalFps()).toBe(12); // default
+  });
+});
+
+describe('add_tag command', () => {
+  it('should add a tag', () => {
+    dispatch(makeCommand('add_tag', { name: 'Walk', startFrame: 0, endFrame: 3 }));
+    expect(ft.getTags()).toHaveLength(1);
+    expect(ft.getTags()[0]?.name).toBe('Walk');
+  });
+
+  it('should undo by removing the tag', () => {
+    dispatch(makeCommand('add_tag', { name: 'Walk', startFrame: 0, endFrame: 3 }));
+    undoLast();
+    expect(ft.getTags()).toHaveLength(0);
+  });
+});
+
+describe('remove_tag command', () => {
+  it('should remove a tag and undo to restore it', () => {
+    const tag = ft.addTag('Idle', 0, 2);
+    dispatch(makeCommand('remove_tag', { id: tag.id }));
+    expect(ft.getTags()).toHaveLength(0);
+
+    undoLast();
+    expect(ft.getTags()).toHaveLength(1);
+    expect(ft.getTags()[0]?.name).toBe('Idle');
+  });
+});
+
+describe('set_origin command', () => {
+  it('should set origin and undo', () => {
+    dispatch(makeCommand('set_origin', { x: 16, y: 32 }));
+    expect(fm.getOriginX()).toBe(16);
+    expect(fm.getOriginY()).toBe(32);
+
+    undoLast();
+    expect(fm.getOriginX()).toBe(0);
+    expect(fm.getOriginY()).toBe(0);
+  });
+});