floatnote 1.0.0

package/tests/preload/preload.test.js

@@ -0,0 +1,218 @@
+// Tests for src/preload.js IPC bridge
+
+describe('Preload IPC Bridge', () => {
+  let mockIpcRenderer;
+  let mockClipboard;
+  let exposedAPI;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Create mock implementations
+    mockIpcRenderer = {
+      on: jest.fn(),
+      send: jest.fn(),
+      invoke: jest.fn(() => Promise.resolve({ success: true }))
+    };
+
+    mockClipboard = {
+      availableFormats: jest.fn(() => []),
+      readImage: jest.fn(() => ({
+        isEmpty: jest.fn(() => true),
+        toDataURL: jest.fn(() => ''),
+        getSize: jest.fn(() => ({ width: 0, height: 0 }))
+      })),
+      readText: jest.fn(() => '')
+    };
+
+    // Create mock API similar to what preload exposes
+    exposedAPI = {
+      onFocusChange: (callback) => {
+        mockIpcRenderer.on('window-focus', (event, focused) => callback(focused));
+      },
+      closeWindow: () => {
+        mockIpcRenderer.send('close-window');
+      },
+      hideWindow: () => {
+        mockIpcRenderer.send('hide-window');
+      },
+      setPinned: (pinned) => {
+        mockIpcRenderer.send('set-pinned', pinned);
+      },
+      setWindowSize: (size) => {
+        mockIpcRenderer.send('set-window-size', size);
+      },
+      setBackgroundMode: (mode) => {
+        mockIpcRenderer.send('set-background-mode', mode);
+      },
+      getClipboardContent: () => {
+        const formats = mockClipboard.availableFormats();
+        const hasImage = formats.some(f => f.includes('image'));
+        const hasText = formats.some(f => f.includes('text'));
+        if (hasImage) {
+          const image = mockClipboard.readImage();
+          if (!image.isEmpty()) {
+            return { type: 'image', dataUrl: image.toDataURL() };
+          }
+        }
+        if (hasText) {
+          const text = mockClipboard.readText();
+          if (text && text.trim()) {
+            return { type: 'text', content: text };
+          }
+        }
+        return null;
+      },
+      readClipboardImage: () => {
+        const image = mockClipboard.readImage();
+        if (!image.isEmpty()) {
+          return image.toDataURL();
+        }
+        return null;
+      },
+      readClipboardText: () => {
+        return mockClipboard.readText();
+      },
+      saveData: (data) => {
+        return mockIpcRenderer.invoke('save-data', data);
+      },
+      loadData: () => {
+        return mockIpcRenderer.invoke('load-data');
+      },
+      resizeWindowLeft: (deltaX) => {
+        mockIpcRenderer.send('resize-window-left', deltaX);
+      },
+      exportToFloatnote: (noteData) => {
+        return mockIpcRenderer.invoke('export-to-floatnote', noteData);
+      },
+      openFloatnoteFolder: () => {
+        return mockIpcRenderer.invoke('open-floatnote-folder');
+      },
+      exportPNG: (imageDataUrl) => {
+        return mockIpcRenderer.invoke('export-png', imageDataUrl);
+      }
+    };
+  });
+
+  describe('Window control functions', () => {
+    test('closeWindow sends close-window IPC message', () => {
+      exposedAPI.closeWindow();
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('close-window');
+    });
+
+    test('hideWindow sends hide-window IPC message', () => {
+      exposedAPI.hideWindow();
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('hide-window');
+    });
+
+    test('setPinned sends set-pinned with value', () => {
+      exposedAPI.setPinned(true);
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('set-pinned', true);
+
+      exposedAPI.setPinned(false);
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('set-pinned', false);
+    });
+
+    test('setWindowSize sends correct size', () => {
+      exposedAPI.setWindowSize('sm');
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('set-window-size', 'sm');
+
+      exposedAPI.setWindowSize('md');
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('set-window-size', 'md');
+
+      exposedAPI.setWindowSize('lg');
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('set-window-size', 'lg');
+    });
+
+    test('setBackgroundMode sends correct mode', () => {
+      exposedAPI.setBackgroundMode('blur');
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('set-background-mode', 'blur');
+
+      exposedAPI.setBackgroundMode('dark');
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('set-background-mode', 'dark');
+
+      exposedAPI.setBackgroundMode('transparent');
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('set-background-mode', 'transparent');
+    });
+  });
+
+  describe('Focus change handling', () => {
+    test('onFocusChange registers callback for window-focus', () => {
+      const callback = jest.fn();
+      exposedAPI.onFocusChange(callback);
+      expect(mockIpcRenderer.on).toHaveBeenCalledWith('window-focus', expect.any(Function));
+    });
+  });
+
+  describe('Clipboard functions', () => {
+    test('getClipboardContent returns null when empty', () => {
+      mockClipboard.availableFormats.mockReturnValue([]);
+      const result = exposedAPI.getClipboardContent();
+      expect(result).toBeNull();
+    });
+
+    test('getClipboardContent returns text when available', () => {
+      mockClipboard.availableFormats.mockReturnValue(['text/plain']);
+      mockClipboard.readText.mockReturnValue('Hello World');
+      const result = exposedAPI.getClipboardContent();
+      expect(result).toEqual({ type: 'text', content: 'Hello World' });
+    });
+
+    test('readClipboardText returns clipboard text', () => {
+      mockClipboard.readText.mockReturnValue('Test text');
+      const result = exposedAPI.readClipboardText();
+      expect(result).toBe('Test text');
+    });
+
+    test('readClipboardImage returns null when empty', () => {
+      mockClipboard.readImage.mockReturnValue({
+        isEmpty: () => true,
+        toDataURL: () => ''
+      });
+      const result = exposedAPI.readClipboardImage();
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Data persistence functions', () => {
+    test('saveData invokes save-data IPC', async () => {
+      const data = { notes: [], settings: {} };
+      await exposedAPI.saveData(data);
+      expect(mockIpcRenderer.invoke).toHaveBeenCalledWith('save-data', data);
+    });
+
+    test('loadData invokes load-data IPC', async () => {
+      await exposedAPI.loadData();
+      expect(mockIpcRenderer.invoke).toHaveBeenCalledWith('load-data');
+    });
+  });
+
+  describe('Window resize', () => {
+    test('resizeWindowLeft sends resize-window-left with delta', () => {
+      exposedAPI.resizeWindowLeft(50);
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('resize-window-left', 50);
+
+      exposedAPI.resizeWindowLeft(-30);
+      expect(mockIpcRenderer.send).toHaveBeenCalledWith('resize-window-left', -30);
+    });
+  });
+
+  describe('Export functions', () => {
+    test('exportToFloatnote invokes export-to-floatnote IPC', async () => {
+      const noteData = { id: '123', lines: [], textItems: [] };
+      await exposedAPI.exportToFloatnote(noteData);
+      expect(mockIpcRenderer.invoke).toHaveBeenCalledWith('export-to-floatnote', noteData);
+    });
+
+    test('openFloatnoteFolder invokes open-floatnote-folder IPC', async () => {
+      await exposedAPI.openFloatnoteFolder();
+      expect(mockIpcRenderer.invoke).toHaveBeenCalledWith('open-floatnote-folder');
+    });
+
+    test('exportPNG invokes export-png IPC with image data', async () => {
+      const imageDataUrl = 'data:image/png;base64,test123';
+      await exposedAPI.exportPNG(imageDataUrl);
+      expect(mockIpcRenderer.invoke).toHaveBeenCalledWith('export-png', imageDataUrl);
+    });
+  });
+});

package/tests/renderer/history.test.js

@@ -0,0 +1,234 @@
+// Tests for renderer undo/redo history
+
+describe('History Management', () => {
+  let history;
+  let historyIndex;
+  const MAX_HISTORY = 50;
+
+  beforeEach(() => {
+    history = [];
+    historyIndex = -1;
+  });
+
+  describe('saveState', () => {
+    test('should add state to history', () => {
+      const state = { lines: [], textItems: [], images: [] };
+      history.push(JSON.stringify(state));
+      historyIndex = 0;
+
+      expect(history.length).toBe(1);
+      expect(historyIndex).toBe(0);
+    });
+
+    test('should increment history index', () => {
+      for (let i = 0; i < 5; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+        historyIndex++;
+      }
+
+      expect(historyIndex).toBe(4);
+      expect(history.length).toBe(5);
+    });
+
+    test('should trim history when exceeding max', () => {
+      for (let i = 0; i < MAX_HISTORY + 10; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+      }
+
+      // Trim to max
+      if (history.length > MAX_HISTORY) {
+        history = history.slice(-MAX_HISTORY);
+        historyIndex = Math.min(historyIndex, history.length - 1);
+      }
+
+      expect(history.length).toBe(MAX_HISTORY);
+    });
+
+    test('should truncate future history when adding new state', () => {
+      // Add 5 states
+      for (let i = 0; i < 5; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+        historyIndex++;
+      }
+
+      // Undo twice
+      historyIndex -= 2;
+
+      // Add new state (should truncate future)
+      history = history.slice(0, historyIndex + 1);
+      history.push(JSON.stringify({ lines: [100] }));
+      historyIndex++;
+
+      expect(history.length).toBe(4);
+      expect(historyIndex).toBe(3);
+    });
+  });
+
+  describe('undo', () => {
+    test('should decrement history index', () => {
+      for (let i = 0; i < 5; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+        historyIndex++;
+      }
+
+      // Perform undo
+      if (historyIndex > 0) {
+        historyIndex--;
+      }
+
+      expect(historyIndex).toBe(3);
+    });
+
+    test('should not go below 0', () => {
+      history.push(JSON.stringify({ lines: [] }));
+      historyIndex = 0;
+
+      // Try to undo when at beginning
+      if (historyIndex > 0) {
+        historyIndex--;
+      }
+
+      expect(historyIndex).toBe(0);
+    });
+
+    test('should restore previous state', () => {
+      history.push(JSON.stringify({ lines: [1, 2, 3] }));
+      historyIndex = 0;
+      history.push(JSON.stringify({ lines: [1, 2, 3, 4] }));
+      historyIndex = 1;
+
+      // Undo
+      historyIndex--;
+      const state = JSON.parse(history[historyIndex]);
+
+      expect(state.lines).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe('redo', () => {
+    test('should increment history index', () => {
+      for (let i = 0; i < 5; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+      }
+      historyIndex = 2;
+
+      // Perform redo
+      if (historyIndex < history.length - 1) {
+        historyIndex++;
+      }
+
+      expect(historyIndex).toBe(3);
+    });
+
+    test('should not go beyond history length', () => {
+      for (let i = 0; i < 3; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+      }
+      historyIndex = 2;
+
+      // Try to redo when at end
+      if (historyIndex < history.length - 1) {
+        historyIndex++;
+      }
+
+      expect(historyIndex).toBe(2);
+    });
+
+    test('should restore next state', () => {
+      history.push(JSON.stringify({ lines: [1] }));
+      history.push(JSON.stringify({ lines: [1, 2] }));
+      history.push(JSON.stringify({ lines: [1, 2, 3] }));
+      historyIndex = 0;
+
+      // Redo
+      historyIndex++;
+      const state = JSON.parse(history[historyIndex]);
+
+      expect(state.lines).toEqual([1, 2]);
+    });
+  });
+
+  describe('canUndo and canRedo', () => {
+    test('canUndo should be false at beginning', () => {
+      history.push(JSON.stringify({ lines: [] }));
+      historyIndex = 0;
+
+      const canUndo = historyIndex > 0;
+      expect(canUndo).toBe(false);
+    });
+
+    test('canUndo should be true with history', () => {
+      for (let i = 0; i < 3; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+        historyIndex++;
+      }
+
+      const canUndo = historyIndex > 0;
+      expect(canUndo).toBe(true);
+    });
+
+    test('canRedo should be false at end', () => {
+      for (let i = 0; i < 3; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+        historyIndex++;
+      }
+
+      const canRedo = historyIndex < history.length - 1;
+      expect(canRedo).toBe(false);
+    });
+
+    test('canRedo should be true after undo', () => {
+      for (let i = 0; i < 3; i++) {
+        history.push(JSON.stringify({ lines: [i] }));
+        historyIndex++;
+      }
+
+      // Undo
+      historyIndex--;
+
+      const canRedo = historyIndex < history.length - 1;
+      expect(canRedo).toBe(true);
+    });
+  });
+
+  describe('State restoration', () => {
+    test('should restore lines correctly', () => {
+      const state = {
+        lines: [
+          { points: [{ x: 0, y: 0 }, { x: 10, y: 10 }], color: '#fff', width: 2 }
+        ]
+      };
+      history.push(JSON.stringify(state));
+
+      const restored = JSON.parse(history[0]);
+      expect(restored.lines.length).toBe(1);
+      expect(restored.lines[0].color).toBe('#fff');
+    });
+
+    test('should restore textItems correctly', () => {
+      const state = {
+        textItems: [
+          { id: '1', text: 'Hello', x: 100, y: 100 }
+        ]
+      };
+      history.push(JSON.stringify(state));
+
+      const restored = JSON.parse(history[0]);
+      expect(restored.textItems.length).toBe(1);
+      expect(restored.textItems[0].text).toBe('Hello');
+    });
+
+    test('should restore images correctly', () => {
+      const state = {
+        images: [
+          { id: '1', dataUrl: 'data:image/png;base64,test', x: 50, y: 50 }
+        ]
+      };
+      history.push(JSON.stringify(state));
+
+      const restored = JSON.parse(history[0]);
+      expect(restored.images.length).toBe(1);
+      expect(restored.images[0].x).toBe(50);
+    });
+  });
+});

package/tests/renderer/notes.test.js

@@ -0,0 +1,262 @@
+// Tests for renderer multi-note system
+
+describe('Multi-Note System', () => {
+  let notes;
+  let currentNoteIndex;
+
+  beforeEach(() => {
+    notes = [];
+    currentNoteIndex = 0;
+  });
+
+  describe('Note creation', () => {
+    test('should create a new note with correct structure', () => {
+      const newNote = {
+        id: Date.now().toString(),
+        lines: [],
+        textItems: [],
+        images: [],
+        createdAt: Date.now(),
+        lastModified: Date.now()
+      };
+      notes.push(newNote);
+
+      expect(notes.length).toBe(1);
+      expect(notes[0].lines).toEqual([]);
+      expect(notes[0].textItems).toEqual([]);
+      expect(notes[0].images).toEqual([]);
+    });
+
+    test('should generate unique IDs', () => {
+      const id1 = Date.now().toString();
+      // Small delay to ensure different timestamp
+      const id2 = (Date.now() + 1).toString();
+
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  describe('Note navigation', () => {
+    beforeEach(() => {
+      // Create 3 notes
+      for (let i = 0; i < 3; i++) {
+        notes.push({
+          id: `note-${i}`,
+          lines: [{ id: `line-${i}` }],
+          textItems: [],
+          images: [],
+          createdAt: Date.now() + i,
+          lastModified: Date.now() + i
+        });
+      }
+      currentNoteIndex = 1;
+    });
+
+    test('previousNote should decrement index', () => {
+      if (currentNoteIndex > 0) {
+        currentNoteIndex--;
+      }
+      expect(currentNoteIndex).toBe(0);
+    });
+
+    test('previousNote should not go below 0', () => {
+      currentNoteIndex = 0;
+      if (currentNoteIndex > 0) {
+        currentNoteIndex--;
+      }
+      expect(currentNoteIndex).toBe(0);
+    });
+
+    test('nextNote should increment index', () => {
+      if (currentNoteIndex < notes.length - 1) {
+        currentNoteIndex++;
+      }
+      expect(currentNoteIndex).toBe(2);
+    });
+
+    test('nextNote should not exceed notes length', () => {
+      currentNoteIndex = 2;
+      if (currentNoteIndex < notes.length - 1) {
+        currentNoteIndex++;
+      }
+      expect(currentNoteIndex).toBe(2);
+    });
+
+    test('nextNote should create new note at end', () => {
+      currentNoteIndex = 2;
+      if (currentNoteIndex === notes.length - 1) {
+        const newNote = {
+          id: `note-${notes.length}`,
+          lines: [],
+          textItems: [],
+          images: [],
+          createdAt: Date.now(),
+          lastModified: Date.now()
+        };
+        notes.push(newNote);
+        currentNoteIndex++;
+      }
+      expect(notes.length).toBe(4);
+      expect(currentNoteIndex).toBe(3);
+    });
+  });
+
+  describe('Note counter', () => {
+    test('should display correct counter format', () => {
+      notes.push({ id: '1' }, { id: '2' }, { id: '3' });
+      currentNoteIndex = 1;
+
+      const counter = `${currentNoteIndex + 1}/${notes.length}`;
+      expect(counter).toBe('2/3');
+    });
+
+    test('should update when navigating', () => {
+      notes.push({ id: '1' }, { id: '2' });
+      currentNoteIndex = 0;
+
+      let counter = `${currentNoteIndex + 1}/${notes.length}`;
+      expect(counter).toBe('1/2');
+
+      currentNoteIndex++;
+      counter = `${currentNoteIndex + 1}/${notes.length}`;
+      expect(counter).toBe('2/2');
+    });
+  });
+
+  describe('Note state management', () => {
+    test('should save current note state before switching', () => {
+      const currentNote = {
+        id: 'note-1',
+        lines: [{ id: 'line-1' }],
+        textItems: [{ id: 'text-1' }],
+        images: []
+      };
+      notes.push(currentNote);
+      notes.push({ id: 'note-2', lines: [], textItems: [], images: [] });
+
+      // Simulate saveCurrentNoteState
+      notes[currentNoteIndex] = { ...currentNote };
+
+      expect(notes[0].lines.length).toBe(1);
+      expect(notes[0].textItems.length).toBe(1);
+    });
+
+    test('should load note state when switching', () => {
+      notes.push({
+        id: 'note-1',
+        lines: [{ id: 'line-1', points: [] }],
+        textItems: [{ id: 'text-1', text: 'Hello' }],
+        images: []
+      });
+
+      const loadedNote = notes[currentNoteIndex];
+      expect(loadedNote.lines.length).toBe(1);
+      expect(loadedNote.textItems.length).toBe(1);
+      expect(loadedNote.textItems[0].text).toBe('Hello');
+    });
+
+    test('should update lastModified timestamp', () => {
+      const note = {
+        id: 'note-1',
+        lines: [],
+        textItems: [],
+        images: [],
+        createdAt: 1000,
+        lastModified: 1000
+      };
+      notes.push(note);
+
+      // Simulate modification
+      note.lastModified = 2000;
+
+      expect(note.lastModified).toBeGreaterThan(note.createdAt);
+    });
+  });
+
+  describe('Note data structure', () => {
+    test('lines should have required properties', () => {
+      const line = {
+        points: [{ x: 0, y: 0 }, { x: 10, y: 10 }],
+        color: '#ffffff',
+        width: 4,
+        objectId: 'obj-1'
+      };
+
+      expect(line.points).toBeDefined();
+      expect(line.color).toBeDefined();
+      expect(line.width).toBeDefined();
+      expect(line.objectId).toBeDefined();
+    });
+
+    test('textItems should have required properties', () => {
+      const textItem = {
+        id: 'text-1',
+        text: 'Sample text',
+        x: 100,
+        y: 200,
+        color: '#ffffff',
+        width: 150
+      };
+
+      expect(textItem.id).toBeDefined();
+      expect(textItem.x).toBeDefined();
+      expect(textItem.y).toBeDefined();
+      expect(textItem.color).toBeDefined();
+    });
+
+    test('images should have required properties', () => {
+      const image = {
+        id: 'img-1',
+        dataUrl: 'data:image/png;base64,test',
+        x: 50,
+        y: 50,
+        width: 200,
+        height: 150
+      };
+
+      expect(image.id).toBeDefined();
+      expect(image.dataUrl).toBeDefined();
+      expect(image.x).toBeDefined();
+      expect(image.y).toBeDefined();
+      expect(image.width).toBeDefined();
+      expect(image.height).toBeDefined();
+    });
+  });
+
+  describe('Clean slate mode', () => {
+    test('should start with empty note when enabled', () => {
+      const settings = { openWithCleanSlate: true };
+
+      if (settings.openWithCleanSlate) {
+        notes = [];
+        notes.push({
+          id: Date.now().toString(),
+          lines: [],
+          textItems: [],
+          images: [],
+          createdAt: Date.now(),
+          lastModified: Date.now()
+        });
+        currentNoteIndex = 0;
+      }
+
+      expect(notes.length).toBe(1);
+      expect(notes[0].lines).toEqual([]);
+    });
+
+    test('should load saved notes when disabled', () => {
+      const settings = { openWithCleanSlate: false };
+      const savedNotes = [
+        { id: '1', lines: [{ id: 'l1' }], textItems: [], images: [] },
+        { id: '2', lines: [], textItems: [{ id: 't1' }], images: [] }
+      ];
+
+      if (!settings.openWithCleanSlate && savedNotes.length > 0) {
+        notes = savedNotes;
+      }
+
+      expect(notes.length).toBe(2);
+      expect(notes[0].lines.length).toBe(1);
+    });
+  });
+});