@franzzemen/brokenstock-shell 0.4.6 → 0.4.7

package/fesm2022/franzzemen-brokenstock-shell.mjs

@@ -2224,38 +2224,92 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.2", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-const STORAGE_KEY = 'shell.commandTerminalVisible';
+/**
+ * The choice a NEW window starts with. Shared by the whole browser.
+ * Written on every toggle, read only at construction.
+ */
+const DEFAULT_KEY = 'shell.commandTerminalVisible';
+/**
+ * THIS window's current choice. Per-window by definition, so two windows cannot
+ * fight over it.
+ */
+const WINDOW_KEY = 'shell.commandTerminalVisible.window';
 /**
  * Controls visibility of the command terminal at the bottom of the shell.
  *
- * State is a single signal, persisted to localStorage so the user's choice
- * survives reloads. The side-menu toggles it; the shell layout reads it to
- * collapse the terminal (and its resize handle) rows.
+ * ⚠ TWO KEYS, AND THE SPLIT IS THE POINT (multiple-windows F6).
+ *
+ * This used to be one `localStorage` value, read once at construction and
+ * written on every change, with nothing listening for another window. That was
+ * correct while the app could only be open once. It is not now: two windows
+ * would each write the shared value on every toggle, so whichever you touched
+ * last decided what BOTH windows got on their next start — a setting that
+ * quietly refuses to stay put, which reads as a bug in the shell rather than in
+ * storage.
+ *
+ * The resolution is not "make them agree". You genuinely may want the terminal
+ * up on the scanner window and out of the way on the other, so forcing them into
+ * step would be the wrong fix as well as a harder one. Instead:
+ *
+ *   - the LIVE state is per-window (`sessionStorage`), so the two never collide
+ *     and a reload still restores what this window had;
+ *   - the DEFAULT for a brand-new window is shared (`localStorage`), so your
+ *     last choice anywhere still carries into the next window and across a
+ *     browser restart, which is the behaviour the single key was providing.
+ *
+ * Both writes are best-effort: losing a remembered layout must never break the
+ * screen trying to remember it.
+ *
+ * ⚠ `visible` is READ-ONLY to the outside and `toggle()` is the only mutator.
+ * It used to be a writable signal persisted by an `effect`, which meant any
+ * caller could `set()` it — and whether that got remembered depended on an
+ * effect firing somewhere else. Persisting inside the one mutator makes it
+ * impossible to change this without persisting it.
  */
 class TerminalVisibilityService {
     constructor() {
-        this.visible = signal(this.#readInitial(), /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "visible" }] : /* istanbul ignore next */ []));
-        effect(() => {
-            const isVisible = this.visible();
-            try {
-                localStorage.setItem(STORAGE_KEY, isVisible ? '1' : '0');
-            }
-            catch {
-                // localStorage unavailable (private mode / SSR) — non-fatal.
-            }
-        });
+        this.#visible = signal(this.#readInitial(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#visible" }] : /* istanbul ignore next */ []));
+        /** Read-only on purpose — see the header. */
+        this.visible = this.#visible.asReadonly();
     }
+    #visible;
     toggle() {
-        this.visible.update(v => !v);
+        const next = !this.#visible();
+        this.#visible.set(next);
+        this.#write(sessionStorage, WINDOW_KEY, next);
+        this.#write(localStorage, DEFAULT_KEY, next);
     }
+    /**
+     * This window's own choice wins; otherwise the last choice made anywhere;
+     * otherwise visible.
+     *
+     * The order matters on a reload: a window that had hidden the terminal must
+     * not have it reappear because another window showed one since.
+     */
     #readInitial() {
+        const own = this.#read(sessionStorage, WINDOW_KEY);
+        if (own !== undefined)
+            return own;
+        const shared = this.#read(localStorage, DEFAULT_KEY);
+        return shared ?? true;
+    }
+    #read(store, key) {
         try {
-            const raw = localStorage.getItem(STORAGE_KEY);
-            return raw === null ? true : raw === '1';
+            const raw = store.getItem(key);
+            return raw === null ? undefined : raw === '1';
         }
         catch {
-            return true;
+            // Storage unavailable (private mode / prerender) — fall through.
+            return undefined;
+        }
+    }
+    #write(store, key, value) {
+        try {
+            store.setItem(key, value ? '1' : '0');
+        }
+        catch {
+            // Non-fatal by policy: a lost layout preference must not break the screen.
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: TerminalVisibilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -2264,7 +2318,7 @@ class TerminalVisibilityService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: TerminalVisibilityService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
+        }] });
 
 /**
  * Elements that mean "the user is typing", where an unmodified shortcut must not fire.