floatnote 1.0.0 → 1.0.6

package/tests/preload/preload.test.js

@@ -1,218 +0,0 @@
-// 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

@@ -1,234 +0,0 @@
-// 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

@@ -1,262 +0,0 @@
-// 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);
-    });
-  });
-});