xtralab 0.14.0 → 0.15.0

package/src/menuBar/index.ts

@@ -0,0 +1,195 @@
+import {
+  ILabShell,
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { IMainMenu, MainMenu } from '@jupyterlab/mainmenu';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+import { CommandToolbarButton, MenuSvg } from '@jupyterlab/ui-components';
+import { Menu, Widget } from '@lumino/widgets';
+
+import { mainMenuIcon } from './icons';
+
+const PLUGIN_ID = 'xtralab:menu-bar';
+
+const OPEN_COMMAND = 'xtralab:open-main-menu';
+const TOGGLE_COMMAND = 'xtralab:toggle-menu-bar';
+
+/**
+ * How long after the popup closes a button press still counts as "close
+ * only". An open Lumino menu closes itself on any outside press from a
+ * document `pointerdown` listener in the capture phase, which runs before
+ * the button's own mousedown handler — so without this window, pressing the
+ * button while the popup is open would close it and instantly reopen it.
+ */
+const REOPEN_GUARD_MS = 250;
+
+/**
+ * Collapse the main menu bar into a compact menu button.
+ *
+ * The menu bar is hidden and a hamburger button in the top bar opens the same
+ * menus as a vertical popup. The popup reuses the live `RankedMenu` instances
+ * owned by the `MainMenu`, so menus added or removed at runtime are reflected
+ * without duplication.
+ *
+ * Hiding covers the `jp-menu-panel` container too, which has its own
+ * `min-height` and would otherwise leave an empty strip. The "Show Menu Bar"
+ * toggle restores the classic bar.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: PLUGIN_ID,
+  description: 'Collapse the main menu bar into a compact menu button.',
+  autoStart: true,
+  requires: [IMainMenu, ILabShell, ISettingRegistry],
+  optional: [ICommandPalette, ITranslator],
+  activate: (
+    app: JupyterFrontEnd,
+    mainMenu: IMainMenu,
+    labShell: ILabShell,
+    settingRegistry: ISettingRegistry,
+    palette: ICommandPalette | null,
+    translator: ITranslator | null
+  ): void => {
+    const { commands } = app;
+    const trans = (translator ?? nullTranslator).load('jupyterlab');
+
+    if (!(mainMenu instanceof MainMenu)) {
+      return;
+    }
+
+    const menuPanel = (): Widget | null =>
+      mainMenu.parent ??
+      Array.from(labShell.widgets('top')).find(w => w.id === 'jp-menu-panel') ??
+      null;
+
+    let visible = false;
+    let button: CommandToolbarButton | null = null;
+    let settings: ISettingRegistry.ISettings | null = null;
+
+    const applyVisibility = (value: boolean): void => {
+      visible = value;
+      mainMenu.setHidden(!value);
+      menuPanel()?.setHidden(!value);
+      button?.setHidden(value);
+      commands.notifyCommandChanged(TOGGLE_COMMAND);
+    };
+
+    mainMenu.hide();
+    menuPanel()?.hide();
+
+    let popup: Menu | null = null;
+    let popupClosedAt = 0;
+
+    const openMenu = (): void => {
+      if (visible) {
+        // The classic bar is on screen; behave like keyboard menu
+        // activation instead of opening a redundant popup that would
+        // compete with the bar for the same Menu instances.
+        mainMenu.activeIndex = 0;
+        mainMenu.openActiveMenu();
+        return;
+      }
+      if (Date.now() - popupClosedAt < REOPEN_GUARD_MS) {
+        return;
+      }
+
+      // One popup instance, rebuilt from the bar's current menus on every
+      // open so runtime menu changes stay reflected. It is a plain Lumino
+      // Menu rather than a MenuSvg: MenuSvg.insertItem re-wraps each
+      // submenu's renderer and insertItem on every call, which would pile
+      // wrappers onto the shared menus across reopens. The svg renderer and
+      // themed-container class are applied directly instead, matching how
+      // the real menus are constructed in MainMenu.
+      if (popup === null) {
+        popup = new Menu({ commands, renderer: MenuSvg.defaultRenderer });
+        popup.addClass('jp-ThemedContainer');
+        popup.addClass('jp-xtralab-MainMenuPopup');
+        popup.aboutToClose.connect(() => {
+          popupClosedAt = Date.now();
+        });
+      } else {
+        popup.clearItems();
+      }
+
+      // Skip empty menus: MenuBar disables their headings, but submenu items
+      // have no such affordance and would open a blank panel.
+      for (const menu of mainMenu.menus) {
+        if (menu.items.length > 0) {
+          popup.addItem({ type: 'submenu', submenu: menu });
+        }
+      }
+
+      const anchor = button?.node.getBoundingClientRect();
+      // The 3px gap matches the detached-dropdown offset chrome.css gives
+      // the real menu bar's dropdowns (.lm-Menu.lm-MenuBar-menu).
+      popup.open(anchor?.left ?? 0, (anchor?.bottom ?? 0) + 3);
+    };
+
+    commands.addCommand(OPEN_COMMAND, {
+      label: trans.__('Open Menu'),
+      caption: trans.__('Open the main menu'),
+      icon: mainMenuIcon,
+      execute: openMenu
+    });
+
+    commands.addCommand(TOGGLE_COMMAND, {
+      label: trans.__('Show Menu Bar'),
+      caption: trans.__('Toggle the visibility of the main menu bar'),
+      isToggled: () => visible,
+      execute: async () => {
+        applyVisibility(!visible);
+        if (settings !== null) {
+          try {
+            await settings.set('visible', visible);
+          } catch (reason) {
+            console.error(
+              'xtralab: failed to persist menu bar visibility',
+              reason
+            );
+          }
+        }
+      }
+    });
+
+    if (palette) {
+      const category = trans.__('Other');
+      palette.addItem({ command: OPEN_COMMAND, category });
+      palette.addItem({ command: TOGGLE_COMMAND, category });
+    }
+
+    Promise.all([settingRegistry.load(PLUGIN_ID), app.restored])
+      .then(([loaded]) => {
+        settings = loaded;
+
+        button = new CommandToolbarButton({
+          commands,
+          id: OPEN_COMMAND,
+          icon: mainMenuIcon,
+          label: '',
+          caption: trans.__('Menu'),
+          noFocusOnClick: true,
+          'aria-haspopup': 'menu'
+        });
+        button.id = 'xtralab-main-menu-button';
+        button.addClass('jp-xtralab-TopBarButton');
+        labShell.add(button, 'top', { rank: 0 });
+
+        const update = (): void => {
+          applyVisibility(loaded.get('visible').composite as boolean);
+        };
+        update();
+        loaded.changed.connect(update);
+      })
+      .catch(reason => {
+        // Without settings the collapsed state cannot be managed (and the
+        // button was never added) — reveal the stock bar rather than leave
+        // the app with no reachable menus.
+        applyVisibility(true);
+        console.error(`Failed to load settings for ${PLUGIN_ID}`, reason);
+      });
+  }
+};
+
+export default plugin;

package/src/sidebar/index.ts

@@ -10,21 +10,46 @@ import type { Widget } from '@lumino/widgets';
 const PLUGIN_ID = 'xtralab:sidebar';
 
 /**
- * Each entry pairs an upstream sidebar widget id with the rank it was
- * originally added at. The ranks come from the upstream extensions —
- * `filebrowser-extension` adds the default browser at rank 100 and
- * `running-extension` adds the running panel at rank 200 — and we reuse
- * them when re-adding so the tab lands back in its usual position.
+ * `rank` is the fallback used when re-adding a hidden tab; the shipped
+ * `layout` setting normally wins because `LabShell.add` merges its
+ * per-widget options over the ones passed in.
  */
 interface ITarget {
   id: string;
   rank: number;
-  settingKey: 'showDefaultFileBrowser' | 'showRunningSessions';
+  settingKey:
+    | 'showTerminals'
+    | 'showFileBrowser'
+    | 'showGitPanel'
+    | 'showDefaultFileBrowser'
+    | 'showRunningSessions'
+    | 'showSearchReplace';
   command: string;
   label: (trans: ReturnType<ITranslator['load']>) => string;
 }
 
 const TARGETS: ITarget[] = [
+  {
+    id: 'xtralab-running-terminals',
+    rank: 1,
+    settingKey: 'showTerminals',
+    command: 'xtralab:toggle-terminals',
+    label: trans => trans.__('Terminals')
+  },
+  {
+    id: 'xtralab:file-browser',
+    rank: 2,
+    settingKey: 'showFileBrowser',
+    command: 'xtralab:toggle-file-browser',
+    label: trans => trans.__('File Browser')
+  },
+  {
+    id: 'jp-git-sessions',
+    rank: 200,
+    settingKey: 'showGitPanel',
+    command: 'xtralab:toggle-git-panel',
+    label: trans => trans.__('Git')
+  },
   {
     id: 'filebrowser',
     rank: 100,
@@ -38,28 +63,29 @@ const TARGETS: ITarget[] = [
     settingKey: 'showRunningSessions',
     command: 'xtralab:toggle-running-sessions',
     label: trans => trans.__('Running Terminals and Kernels')
+  },
+  {
+    id: 'jp-search-replace',
+    rank: 900,
+    settingKey: 'showSearchReplace',
+    command: 'xtralab:toggle-search-replace',
+    label: trans => trans.__('Search and Replace')
   }
 ];
 
 /**
- * Lets the user toggle individual left-sidebar tabs from
- * View > Appearance > Left Sidebar. Removing a widget from a `LabShell`
- * side area is done by setting `widget.parent = null`: the StackedPanel
- * emits `widgetRemoved`, which the SideBarHandler responds to by removing
- * the matching tab. The widget instance is preserved, so we can re-add it
- * later via `labShell.add` with its original rank.
- *
- * The menu placement is contributed declaratively in
- * `schema/sidebar.json`, so this plugin only registers commands and
- * applies state — it does not touch `IMainMenu` directly.
- *
- * The preference is persisted to `xtralab:sidebar` settings so the choice
- * survives reloads.
+ * Toggles individual sidebar tabs from View > Appearance > Sidebars,
+ * whichever side a tab currently lives on. Hiding detaches the widget
+ * (`widget.parent = null`) while keeping the instance for a later
+ * re-add; the preference persists in this plugin's settings. Which side
+ * a hidden tab came from is only tracked in-memory, so after a reload a
+ * re-shown tab lands on the left. The menu placement is contributed
+ * declaratively in `schema/sidebar.json`.
  */
 const plugin: JupyterFrontEndPlugin<void> = {
   id: PLUGIN_ID,
   description:
-    'Toggle visibility of selected sidebar tabs (default file browser, running sessions) from the View menu.',
+    'Toggle visibility of individual sidebar tabs from the View menu.',
   autoStart: true,
   requires: [ILabShell],
   optional: [ISettingRegistry, ITranslator],
@@ -72,31 +98,40 @@ const plugin: JupyterFrontEndPlugin<void> = {
     const trans = (translator ?? nullTranslator).load('jupyterlab');
     const { commands } = app;
 
-    // Cache widget instances so we can re-add them after `widget.parent =
-    // null` has detached them from the sidebar. The widget is no longer
-    // reachable through `labShell.widgets('left')` once removed, so a
-    // missing cache entry would leave us unable to bring the tab back.
+    // Detached widgets are unreachable via `labShell.widgets(...)`; keep
+    // instances here so hidden tabs can be re-added.
     const widgetCache = new Map<string, Widget>();
 
-    const findInSidebar = (id: string): Widget | null => {
-      for (const w of labShell.widgets('left')) {
-        if (w.id === id) {
-          return w;
+    // Side each hidden widget was removed from, so re-showing restores it
+    // there.
+    const hiddenFrom = new Map<string, 'left' | 'right'>();
+
+    const findInSidebars = (
+      id: string
+    ): { widget: Widget; area: 'left' | 'right' } | null => {
+      for (const area of ['left', 'right'] as const) {
+        for (const widget of labShell.widgets(area)) {
+          if (widget.id === id) {
+            return { widget, area };
+          }
         }
       }
       return null;
     };
 
+    const locate = (id: string): 'left' | 'right' | null =>
+      findInSidebars(id)?.area ?? null;
+
     const captureWidget = (id: string): Widget | null => {
       const cached = widgetCache.get(id);
       if (cached && !cached.isDisposed) {
         return cached;
       }
-      const found = findInSidebar(id);
+      const found = findInSidebars(id);
       if (found) {
-        widgetCache.set(id, found);
+        widgetCache.set(id, found.widget);
       }
-      return found;
+      return found?.widget ?? null;
     };
 
     let settings: ISettingRegistry.ISettings | null = null;
@@ -112,19 +147,24 @@ const plugin: JupyterFrontEndPlugin<void> = {
     const apply = (target: ITarget): void => {
       const widget = captureWidget(target.id);
       if (!widget) {
-        // The upstream widget hasn't been added yet (or the extension is
-        // disabled). Nothing to do — the next time `apply` runs and finds
-        // it, the preference will take effect.
+        // Not seen yet (extension disabled or not added) — nothing to do.
+        return;
+      }
+      const area = locate(target.id);
+      if (!area && widget.parent !== null) {
+        // Attached outside the sidebars — leave it alone.
         return;
       }
-      const present = findInSidebar(target.id) !== null;
       const wantPresent = readPreference(target);
-      if (wantPresent && !present) {
-        labShell.add(widget, 'left', { rank: target.rank });
-      } else if (!wantPresent && present) {
-        // Setting `parent = null` triggers SideBarHandler's
-        // `_onWidgetRemoved`, which strips the tab while leaving the
-        // widget instance alive for a later re-add.
+      if (wantPresent && !area) {
+        labShell.add(widget, hiddenFrom.get(target.id) ?? 'left', {
+          rank: target.rank
+        });
+        hiddenFrom.delete(target.id);
+      } else if (!wantPresent && area) {
+        hiddenFrom.set(target.id, area);
+        // Detaching makes the SideBarHandler remove the tab while the
+        // widget instance stays alive for a later re-add.
         widget.parent = null;
       }
     };
@@ -139,14 +179,21 @@ const plugin: JupyterFrontEndPlugin<void> = {
       commands.addCommand(target.command, {
         label: target.label(trans),
         isToggled: () => readPreference(target),
+        isVisible: () => {
+          // List only tabs this plugin can manage: in a sidebar, or
+          // hidden by this plugin (`parent === null`).
+          const widget = captureWidget(target.id);
+          return (
+            widget !== null &&
+            (widget.parent === null || locate(target.id) !== null)
+          );
+        },
         execute: async () => {
           const next = !readPreference(target);
           if (settings) {
             try {
               await settings.set(target.settingKey, next);
-              // `settings.changed` will fire and drive `apply` + the
-              // command-state refresh. Returning here keeps the toggle's
-              // single source of truth in the settings registry.
+              // `settings.changed` drives `apply` and the state refresh.
               return;
             } catch (reason) {
               console.error(
@@ -155,9 +202,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
               );
             }
           }
-          // No settings registry available (or the write failed): fall
-          // back to applying the change in-memory so the toggle still
-          // works for the current session.
+          // No settings registry (or the write failed): apply in-memory
+          // for the current session only.
           apply(target);
           commands.notifyCommandChanged(target.command);
         }
@@ -179,11 +225,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     }
 
     void app.restored.then(() => {
-      // Capture references first so a hidden-on-startup widget is still
-      // recoverable later. `apply` would also do the lookup, but only on
-      // the targets that need to stay visible — by capturing every target
-      // here we keep the cache populated for both directions of the
-      // toggle.
+      // Capture every widget before applying, so tabs hidden on startup
+      // stay recoverable.
       for (const target of TARGETS) {
         captureWidget(target.id);
       }

package/src/terminals/index.ts

@@ -3,7 +3,11 @@ import {
   JupyterFrontEnd,
   JupyterFrontEndPlugin
 } from '@jupyterlab/application';
-import { Dialog, showDialog } from '@jupyterlab/apputils';
+import {
+  Dialog,
+  IMovableSectionRegistry,
+  showDialog
+} from '@jupyterlab/apputils';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
@@ -36,9 +40,11 @@ const PLUGIN_ID = 'xtralab:terminals';
  *
  * Clicking a row activates the existing tab if one is open, or reopens
  * the session in a fresh terminal widget (`terminal:open`). The inline
- * `×` button shuts the session down on the server. The header carries a
- * `+` button and a stop button (the latter shuts every session down at
- * once, after a confirmation).
+ * `×` button shuts the session down on the server. The Terminals
+ * section's title toolbar carries a `+` button and a stop button (the
+ * latter shuts every session down at once, after a confirmation).
+ *
+ * The list is one movable section, and other panels' sections can move in.
  *
  * The `+` button drops down a menu — built from the launcher's shared
  * `IAgentRegistry` — listing each available agent (Claude, Codex, …)
@@ -65,7 +71,8 @@ const plugin: JupyterFrontEndPlugin<IAgentTerminals> = {
     IAgentRegistry,
     IEditorRegistry,
     IAgentSessions,
-    ISettingRegistry
+    ISettingRegistry,
+    IMovableSectionRegistry
   ],
   activate: (
     app: JupyterFrontEnd,
@@ -75,7 +82,8 @@ const plugin: JupyterFrontEndPlugin<IAgentTerminals> = {
     agentRegistry: IAgentRegistry | null,
     editorRegistry: IEditorRegistry | null,
     agentSessions: IAgentSessions | null,
-    settingRegistry: ISettingRegistry | null
+    settingRegistry: ISettingRegistry | null,
+    movableSections: IMovableSectionRegistry | null
   ): IAgentTerminals => {
     const trans = (translator ?? nullTranslator).load('jupyterlab');
 
@@ -262,6 +270,16 @@ const plugin: JupyterFrontEndPlugin<IAgentTerminals> = {
       restorer.add(panel, panel.id);
     }
 
+    void app.restored.then(() => {
+      panel.expandOwnSection();
+    });
+
+    if (movableSections) {
+      movableSections.registerSource(PLUGIN_ID, trans.__('Terminals'), panel);
+      movableSections.registerTarget(PLUGIN_ID, trans.__('Terminals'), panel);
+      panel.announceSections();
+    }
+
     // The latest-activity line under each agent row is on by default; honour
     // the `showAgentActivity` setting so it can be turned off. Read on load and
     // re-applied on every change.