Work on issue #10, remember space bounds when resize, move, close happens.

Author: codedread

CHANGELOG.md

@@ -6,9 +6,9 @@ All notable changes to this project will be documented in this file.
 
 ### Changes
 
+- Work on [issue #10](https://github.com/codedread/spaces/issues/10): Remember named space window bounds in the internal database.
 - Fixed [issue #20](https://github.com/codedread/spaces/issues/20): Close browser windows from the Spaces window.
-- Increased unit test coverage from 10.75% to 11.41%.
-
+- Increased unit test coverage from 10.75% to 14.75%.
 
 ## [1.1.6] - 2025-09-17
 

js/background/background.js

@@ -11,6 +11,7 @@ import { dbService } from './dbService.js';
 import { spacesService } from './spacesService.js';
 import * as common from '../common.js';
 /** @typedef {common.Space} Space */
+/** @typedef {import('./dbService.js').WindowBounds} WindowBounds */
 
 // eslint-disable-next-line no-unused-vars, no-var
 let spacesPopupWindowId = false;
@@ -169,6 +170,19 @@ export function initializeServiceWorker() {
         spacesService.handleWindowFocussed(windowId);
     });
 
+    // Listen for window bounds changes (resize/move) with debouncing
+    chrome.windows.onBoundsChanged.addListener(async (window) => {
+        if (checkInternalSpacesWindows(window.id, false)) return;
+        
+        // Capture bounds - await ensures proper event ordering and timer management
+        await spacesService.captureWindowBounds(window.id, {
+            left: window.left,
+            top: window.top,
+            width: window.width, 
+            height: window.height
+        });
+    });
+
     // add listeners for message requests from other extension pages (spaces.html & tab.html)
 
     chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
@@ -335,7 +349,14 @@ async function processMessage(request, sender) {
             }
 
             try {
-                await chrome.windows.get(windowId);
+                const window = await chrome.windows.get(windowId);
+                // Capture bounds before programmatically closing the window
+                await spacesService.captureWindowBounds(windowId, {
+                    left: window.left,
+                    top: window.top,
+                    width: window.width,
+                    height: window.height
+                });
                 await chrome.windows.remove(windowId);
                 return true;
             } catch (error) {
@@ -909,7 +930,13 @@ async function handleSaveNewSession(windowId, sessionName, deleteOld) {
     const result = await spacesService.saveNewSession(
         sessionName,
         curWindow.tabs,
-        curWindow.id
+        curWindow.id,
+        { 
+            left: curWindow.left, 
+            top: curWindow.top, 
+            width: curWindow.width, 
+            height: curWindow.height 
+        },
     );
     return result ?? false;
 }

js/background/dbService.js

@@ -2,6 +2,14 @@
 
 import { db, Server } from './db.js';
 
+/**
+ * @typedef WindowBounds
+ * @property {number} left The x-coordinate of the window's left edge
+ * @property {number} top The y-coordinate of the window's top edge
+ * @property {number} width The width of the window
+ * @property {number} height The height of the window
+ */
+
 /**
  * @typedef Session
  * @property {number} id Auto-generated indexedDb object id
@@ -10,6 +18,7 @@ import { db, Server } from './db.js';
  * @property {Array} tabs An array of chrome tab objects (often taken from the chrome window obj)
  * @property {Array} history An array of chrome tab objects that have been removed from the session
  * @property {Date} lastAccess Timestamp that gets updated with every window focus
+ * @property {WindowBounds?} windowBounds Optional saved window position and size
  */
 
 /**

js/background/spacesService.js

@@ -25,6 +25,7 @@ class SpacesService {
     constructor() {
         this.tabHistoryUrlMap = {};
         this.closedWindowIds = {};
+        this.boundsUpdateTimers = {};
         this.sessionUpdateTimers = {};
         this.historyQueue = [];
         this.eventQueueCount = 0;
@@ -405,6 +406,50 @@ class SpacesService {
         return null;
     }
 
+    /**
+     * Captures and stores window bounds for a window with debouncing.
+     * This is called when window bounds change to ensure we have current bounds
+     * without excessive database writes during rapid resize/move operations.
+     *
+     * @param {number} windowId - The ID of the window to capture bounds for
+     * @param {Object} bounds - The window bounds object with left, top, width, height
+     * @returns {Promise<void>}
+     */
+    async captureWindowBounds(windowId, bounds) {
+        await this.ensureInitialized();
+        
+        const session = await this.getSessionByWindowId(windowId);
+        if (session && session.id) {
+            // Update bounds in memory immediately for responsiveness
+            session.windowBounds = {
+                left: bounds.left,
+                top: bounds.top, 
+                width: bounds.width,
+                height: bounds.height
+            };
+            
+            if (debug) {
+                // eslint-disable-next-line no-console
+                console.log(`Captured window bounds for session ${session.id}:`, session.windowBounds);
+            }
+
+            // Debounce database writes to avoid excessive I/O during rapid resize/move
+            clearTimeout(this.boundsUpdateTimers[windowId]);
+            this.boundsUpdateTimers[windowId] = setTimeout(async () => {
+                try {
+                    // Save bounds to database after debounce period
+                    await this._updateSessionSync(session);
+                    if (debug) {
+                        // eslint-disable-next-line no-console
+                        console.log(`Saved window bounds to database for session ${session.id}`);
+                    }
+                } catch (error) {
+                    console.error(`Error saving bounds for session ${session.id}:`, error);
+                }
+            }, 1000); // 1 second debounce - adjust as needed
+        }
+    }
+
     // event listener functions for window and tab events
     // (events are received and screened first in background.js)
     // -----------------------------------------------------------------------------------------
@@ -530,6 +575,7 @@ class SpacesService {
             }
 
             this.closedWindowIds[windowId] = true;
+            clearTimeout(this.boundsUpdateTimers[windowId]);
             clearTimeout(this.sessionUpdateTimers[windowId]);
         }
 
@@ -538,7 +584,7 @@ class SpacesService {
             // if this is a saved session then just remove the windowId reference
             if (session.id) {
                 session.windowId = false;
-                // Persist the cleared windowId to database with sync
+                // Persist the window to database with sync
                 await this._updateSessionSync(session);
 
                 // else if it is temporary session then remove the session from the cache
@@ -856,11 +902,12 @@ class SpacesService {
      * @param {string} sessionName - The name for the new session
      * @param {Array<Object>} tabs - Array of tab objects containing URL and other tab properties
      * @param {number|false} windowId - The window ID to associate with this session, or false for no association
+     * @param {WindowBounds} [windowBounds] - Optional window bounds to save with the session
      * @returns {Promise<Session|null>} Promise that resolves to:
      *   - Session object with id property if successfully created
      *   - null if session creation failed, no tabs were provided, or attempted on already saved session
      */
-    async saveNewSession(sessionName, tabs, windowId) {
+    async saveNewSession(sessionName, tabs, windowId, windowBounds) {
         await this.ensureInitialized();
 
         if (!tabs) {
@@ -909,6 +956,11 @@ class SpacesService {
         session.sessionHash = sessionHash;
         session.tabs = tabs;
         session.lastAccess = new Date();
+        
+        // Add window bounds if provided
+        if (windowBounds) {
+            session.windowBounds = windowBounds;
+        }
 
         // save session to db - this should only be called on temporary sessions (id: false)
         try {

manifest.json

@@ -1,7 +1,7 @@
 {
     "name": "Spaces",
     "description": "Intuitive tab management",
-    "version": "1.1.7.0",
+    "version": "1.1.7.1",
     "permissions": [
         "contextMenus",
         "favicon",