xtralab 0.4.0 → 0.6.0

package/lib/statusBar/widget.js

@@ -1,237 +0,0 @@
-import { nullTranslator } from '@jupyterlab/translation';
-import { closeIcon, terminalIcon, VDomModel, VDomRenderer } from '@jupyterlab/ui-components';
-import * as React from 'react';
-/**
- * Source-of-truth model for the status bar. Each running terminal
- * session known to the server is one entry; the registry caches the
- * last `widget.title.label` we observed so the agent name (or any
- * xterm-published title) survives the user closing the tab while the
- * session continues running on the backend.
- *
- * Two upstream signals feed the model:
- *   - `serviceManager.terminals.runningChanged` is the authoritative
- *     list of live sessions; everything not in it has been shut down
- *     server-side and we must drop it.
- *   - `tracker.widgetAdded` plus the per-widget `title.changed` /
- *     `disposed` signals keep our label cache in sync with whatever
- *     xterm/the launcher has set on the open tabs.
- *
- * `stateChanged` is reused for both kinds of update so consumers
- * (the per-session status item, the plugin's add/remove sync) can
- * subscribe once.
- */
-export class SessionRegistry extends VDomModel {
-    constructor(serviceManager, tracker) {
-        super();
-        this._labels = new Map();
-        this._ranks = new Map();
-        this._live = new Set();
-        this._nextRank = 100;
-        this._terminals = serviceManager.terminals;
-        this._tracker = tracker;
-        this._terminals.runningChanged.connect(this._onRunningChanged, this);
-        this._tracker.widgetAdded.connect(this._onWidgetAdded, this);
-        this._tracker.forEach(widget => this._trackWidget(widget));
-        this._refreshLive();
-    }
-    /**
-     * Names of all live sessions, ordered by their stable rank so the
-     * status bar items keep their slots as new sessions are added.
-     */
-    sessionNames() {
-        const names = Array.from(this._live);
-        names.sort((a, b) => this.rankFor(a) - this.rankFor(b));
-        return names;
-    }
-    /**
-     * True iff the named session is still on the server. Used by the
-     * per-session item to render `null` during the brief window between
-     * the session's shutdown and the plugin disposing the item.
-     */
-    has(name) {
-        return this._live.has(name);
-    }
-    /**
-     * Display name for the session. The cache wins because it only
-     * holds "real" labels (the launcher's agent name or an xterm escape
-     * sequence — see `_cacheLabel` for the filter); reading it first
-     * prevents the transient `Terminal {name}` an XTerm widget shows
-     * during reconnect from flickering into the status bar. The live
-     * widget title is used when no cache exists, and the
-     * `Terminal {name}` fallback covers sessions we have never seen a
-     * widget for (e.g. surviving a lab reload).
-     */
-    labelFor(name) {
-        const cached = this._labels.get(name);
-        if (cached) {
-            return cached;
-        }
-        const widget = this.widgetFor(name);
-        if (widget && widget.title.label) {
-            return widget.title.label;
-        }
-        return `Terminal ${name}`;
-    }
-    /**
-     * Return the open widget for a session, if any. The status item
-     * uses this to switch behaviour between "activate existing tab"
-     * and "open a new tab connected to the live session".
-     */
-    widgetFor(name) {
-        var _a;
-        return ((_a = this._tracker.find(widget => widget.content.session.name === name)) !== null && _a !== void 0 ? _a : null);
-    }
-    /**
-     * Stable per-session rank assigned in observation order. Reused
-     * across `registerStatusItem` calls so an item that is briefly
-     * unregistered (e.g. while a widget is being recreated) lands back
-     * in the same slot. Cleaned up when the session is shut down so the
-     * counter does not grow without bound across long sessions.
-     */
-    rankFor(name) {
-        let rank = this._ranks.get(name);
-        if (rank === undefined) {
-            rank = this._nextRank++;
-            this._ranks.set(name, rank);
-        }
-        return rank;
-    }
-    dispose() {
-        if (this.isDisposed) {
-            return;
-        }
-        this._terminals.runningChanged.disconnect(this._onRunningChanged, this);
-        this._tracker.widgetAdded.disconnect(this._onWidgetAdded, this);
-        this._tracker.forEach(widget => this._untrackWidget(widget));
-        super.dispose();
-    }
-    _refreshLive() {
-        const next = new Set();
-        for (const model of this._terminals.running()) {
-            next.add(model.name);
-        }
-        this._live = next;
-        // Drop cache + rank entries for sessions that have been shut down
-        // server-side. Without this prune the rank counter would keep
-        // climbing across long-running labs as terminals come and go.
-        for (const name of Array.from(this._labels.keys())) {
-            if (!next.has(name)) {
-                this._labels.delete(name);
-            }
-        }
-        for (const name of Array.from(this._ranks.keys())) {
-            if (!next.has(name)) {
-                this._ranks.delete(name);
-            }
-        }
-    }
-    _onRunningChanged(_, sessions) {
-        this._live = new Set(sessions.map(model => model.name));
-        for (const name of Array.from(this._labels.keys())) {
-            if (!this._live.has(name)) {
-                this._labels.delete(name);
-            }
-        }
-        for (const name of Array.from(this._ranks.keys())) {
-            if (!this._live.has(name)) {
-                this._ranks.delete(name);
-            }
-        }
-        this.stateChanged.emit();
-    }
-    _onWidgetAdded(_, widget) {
-        this._trackWidget(widget);
-        this.stateChanged.emit();
-    }
-    _trackWidget(widget) {
-        const name = widget.content.session.name;
-        this._cacheLabel(name, widget.title.label);
-        widget.title.changed.connect(this._onTitleChanged, this);
-        widget.disposed.connect(this._onWidgetDisposed, this);
-    }
-    _untrackWidget(widget) {
-        widget.title.changed.disconnect(this._onTitleChanged, this);
-        widget.disposed.disconnect(this._onWidgetDisposed, this);
-    }
-    _onTitleChanged(title) {
-        var _a;
-        const owner = title.owner;
-        const session = (_a = owner.content) === null || _a === void 0 ? void 0 : _a.session;
-        if (!session) {
-            return;
-        }
-        this._cacheLabel(session.name, title.label);
-        this.stateChanged.emit();
-    }
-    /**
-     * Update the cached label for a session, but only when the new
-     * label is "real" — non-empty and not one of the transient defaults
-     * the XTerm widget cycles through during reconnect (`'...'` while
-     * the websocket is opening, `'Terminal {name}'` once
-     * `_initialConnection` fires). Without the filter, briefly
-     * reopening a tab while an agent has yet to re-emit its xterm
-     * title escape sequence would clobber the cached agent name with
-     * `Terminal 1`, which is exactly the regression we are guarding
-     * against. Live widget titles still display whatever the widget
-     * currently holds because `labelFor` consults the widget first;
-     * the filter only affects what survives a tab close.
-     */
-    _cacheLabel(name, label) {
-        if (!label) {
-            return;
-        }
-        if (label === '...' || label === `Terminal ${name}`) {
-            return;
-        }
-        this._labels.set(name, label);
-    }
-    _onWidgetDisposed(widget) {
-        // The widget is gone but the session may still be running on the
-        // server — keep the cached label so the status item keeps the
-        // agent's name when the user reopens the tab. We only clean up
-        // our subscriptions here; the cache is purged by `runningChanged`
-        // once the session itself goes away.
-        this._untrackWidget(widget);
-        this.stateChanged.emit();
-    }
-}
-/**
- * One status bar item per live terminal session. Renders a terminal
- * icon plus the session's label, with an inline shutdown button that
- * appears on hover/focus. The item delegates click handling to the
- * plugin so the lifecycle (create/dispose) and the user-facing
- * behaviour (activate vs. reopen, shutdown) live in one place.
- */
-export class TerminalSessionItem extends VDomRenderer {
-    constructor(options) {
-        var _a;
-        super(options.registry);
-        this._sessionName = options.sessionName;
-        this._trans = (_a = options.trans) !== null && _a !== void 0 ? _a : nullTranslator.load('jupyterlab');
-        this._onActivate = options.onActivate;
-        this._onShutdown = options.onShutdown;
-        this.addClass('jp-mod-highlighted');
-        this.addClass('jp-xtralab-StatusBar-Terminal');
-    }
-    render() {
-        if (!this.model || !this.model.has(this._sessionName)) {
-            return null;
-        }
-        const trans = this._trans;
-        const label = this.model.labelFor(this._sessionName);
-        const hasWidget = this.model.widgetFor(this._sessionName) !== null;
-        const tooltip = hasWidget
-            ? trans.__('Activate %1', label)
-            : trans.__('Reopen %1', label);
-        this.node.title = tooltip;
-        return (React.createElement("div", { className: "jp-xtralab-StatusBar-Terminal-Container" },
-            React.createElement("button", { type: "button", className: "jp-xtralab-StatusBar-Terminal-Activate", onClick: () => this._onActivate(this._sessionName), "aria-label": tooltip },
-                React.createElement(terminalIcon.react, { tag: "span", verticalAlign: "middle", stylesheet: "statusBar" }),
-                React.createElement("span", { className: "jp-xtralab-StatusBar-Terminal-Label" }, label)),
-            React.createElement("button", { type: "button", className: "jp-xtralab-StatusBar-Terminal-Close", onClick: event => {
-                    event.stopPropagation();
-                    this._onShutdown(this._sessionName);
-                }, title: trans.__('Shut down %1', label), "aria-label": trans.__('Shut down %1', label) },
-                React.createElement(closeIcon.react, { tag: "span", verticalAlign: "middle", stylesheet: "statusBar" }))));
-    }
-}

package/src/git/icons.ts

@@ -1,20 +0,0 @@
-import { LabIcon } from '@jupyterlab/ui-components';
-
-/**
- * The branch glyph used as the git panel's sidebar tab icon. Defined as a
- * `LabIcon` (rather than a CSS-only mask) so it picks up JupyterLab's icon
- * recoloring and inverse-color sidebar painting automatically.
- *
- * Source: `git-branch` from SVG Repo (https://www.svgrepo.com/svg/377352/git-branch),
- * part of the same Pixelarticons family as the xtralab file browser's `file-tree`
- * icon, so the two sidebar tab glyphs read as a matched set. The original
- * `fill="#000000"` is replaced with `fill="currentColor"` and the root element
- * is given the `jp-icon3` class so the icon picks up JupyterLab's theme color
- * and the sidebar's inverse-color painting automatically.
- */
-export const gitIcon = new LabIcon({
-  name: 'xtralab:git',
-  svgstr: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="jp-icon3" fill="currentColor">
-  <path d="M5 2h2v12h3v3h7v-7h-3V2h8v8h-3v9h-9v3H2v-8h3V2zm15 6V4h-4v4h4zM8 19v-3H4v4h4v-1z"/>
-</svg>`
-});

package/src/git/panel.tsx

@@ -1,56 +0,0 @@
-import * as React from 'react';
-
-import { ReactWidget } from '@jupyterlab/ui-components';
-import { Signal, ISignal } from '@lumino/signaling';
-
-import { gitIcon } from './icons';
-import { GitPanelComponent, IGitPanelHandlers } from './panelComponent';
-
-/**
- * The id and CSS class used for the git panel widget. The id ends up as the
- * sidebar tab id (so layout restoration can find the widget) and the CSS
- * class lets per-panel styles attach without leaking to other widgets.
- */
-export const GIT_PANEL_ID = 'xtralab:git-panel';
-export const GIT_PANEL_CSS_CLASS = 'jp-xtralab-GitPanel';
-
-/**
- * The lumino host widget for the git changes panel. Owns the `refresh`
- * signal that the React component listens to, and exposes a typed callback
- * surface (`handlers`) the React component uses to react to user actions.
- */
-export class GitPanel extends ReactWidget {
-  constructor(handlers: IGitPanelHandlers) {
-    super();
-    this.id = GIT_PANEL_ID;
-    this.title.icon = gitIcon;
-    this.title.caption = 'Git Changes';
-    this.addClass(GIT_PANEL_CSS_CLASS);
-    this._handlers = handlers;
-  }
-
-  /**
-   * Public refresh hook called by the plugin when something happened that
-   * invalidates the current view (the user clicked the toolbar refresh, the
-   * file browser refreshed, a focused notebook saved, …).
-   */
-  refresh(): void {
-    this._refreshRequested.emit();
-  }
-
-  get refreshRequested(): ISignal<this, void> {
-    return this._refreshRequested;
-  }
-
-  protected render(): React.ReactElement {
-    return (
-      <GitPanelComponent
-        handlers={this._handlers}
-        refreshSignal={this._refreshRequested}
-      />
-    );
-  }
-
-  private _handlers: IGitPanelHandlers;
-  private _refreshRequested = new Signal<this, void>(this);
-}