@hydranium/glsp-client-theia 1.0.0-next.23 → 1.0.0-next.232

package/src/browser/status-overlay.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { type StatusAction, StatusOverlay } from '@eclipse-glsp/client';
+import { injectable } from '@theia/core/shared/inversify';
+
+/**
+ * GLSP's status overlay, kept on the page.
+ *
+ * It inserts its element into the diagram's base div when the diagram starts,
+ * and sprotty's first render then replaces that div with its own, so the element
+ * is left detached and no status it shows is ever seen. This puts the element
+ * back into the current base div before it shows anything.
+ */
+@injectable()
+export class HydraniumStatusOverlay extends StatusOverlay {
+   override handle(action: StatusAction): void {
+      this.reattach();
+      super.handle(action);
+   }
+
+   override show(...args: Parameters<StatusOverlay['show']>): void {
+      super.show(...args);
+      this.reattach();
+   }
+
+   protected reattach(): void {
+      const container = this.containerElement as HTMLElement | undefined;
+      if (!container || container.isConnected) {
+         return;
+      }
+      const parent = this.getParentContainer();
+      if (parent) {
+         this.insertContainerIntoParent(container, parent);
+      }
+   }
+}

package/src/browser/window-session.ts

@@ -0,0 +1,114 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { randomUuid } from '@hydranium/protocol';
+// Not the `@theia/core/lib/browser` barrel, which touches DOM globals at load.
+import { FrontendApplicationContribution } from '@theia/core/lib/browser/frontend-application-contribution';
+import { injectable, type interfaces } from '@theia/core/shared/inversify';
+
+/** The `sessionStorage` key of the window's {@link WindowSession}. */
+export const WINDOW_SESSION_KEY = 'hydranium.glsp.windowSession';
+/** Holds the id of the window session the last page in the tab left, for the next page to take up. */
+export const RELEASED_WINDOW_SESSION_KEY = 'hydranium.glsp.releasedWindowSession';
+
+/** The window's part of every diagram client id it opens, and the token its diagrams resume with. */
+export interface WindowSession {
+   readonly id: string;
+   readonly resumeToken: string;
+}
+
+export function isWindowSession(value: unknown): value is WindowSession {
+   return (
+      typeof value === 'object' &&
+      value !== null &&
+      typeof (value as WindowSession).id === 'string' &&
+      typeof (value as WindowSession).resumeToken === 'string'
+   );
+}
+
+export const WindowSessionService = Symbol('WindowSessionService');
+
+/**
+ * The page's window session: the one the last page in this tab left, so a
+ * reload resumes its diagrams, and a new one otherwise.
+ *
+ * A reload only has a session to resume on a server that outlives the page; a
+ * server started per frontend, as a Theia plugin host's is, is new after one.
+ */
+export interface WindowSessionService {
+   current(): WindowSession;
+}
+
+/**
+ * Keeps the window session in `sessionStorage` and hands it on only as the page
+ * leaves. A duplicated tab copies `sessionStorage` while the original page is
+ * still live, so the copy finds no released session and draws its own; taking
+ * the original's would end the original's diagram sessions. Where
+ * `sessionStorage` is unavailable the session lasts for the page, and a reload
+ * resumes nothing.
+ *
+ * Claimed as the frontend starts, not with the first diagram: until then the
+ * released mark stays, and a tab duplicated meanwhile would take it too. A page
+ * restored from the back-forward cache takes the mark back, since Theia
+ * before 1.75 leaves it live without a reload.
+ */
+@injectable()
+export class DefaultWindowSessionService implements WindowSessionService, FrontendApplicationContribution {
+   protected session?: WindowSession;
+
+   initialize(): void {
+      this.current();
+   }
+
+   current(): WindowSession {
+      this.session ??= this.claim();
+      return this.session;
+   }
+
+   protected claim(): WindowSession {
+      const created: WindowSession = { id: randomUuid(), resumeToken: randomUuid() };
+      try {
+         const storage = globalThis.sessionStorage;
+         const stored = this.parse(storage.getItem(WINDOW_SESSION_KEY));
+         const session = stored && storage.getItem(RELEASED_WINDOW_SESSION_KEY) === stored.id ? stored : created;
+         storage.setItem(WINDOW_SESSION_KEY, JSON.stringify(session));
+         storage.removeItem(RELEASED_WINDOW_SESSION_KEY);
+         globalThis.addEventListener?.('pagehide', () => storage.setItem(RELEASED_WINDOW_SESSION_KEY, session.id));
+         globalThis.addEventListener?.('pageshow', event => {
+            if ((event as PageTransitionEvent).persisted) {
+               storage.removeItem(RELEASED_WINDOW_SESSION_KEY);
+            }
+         });
+         return session;
+      } catch {
+         return created;
+      }
+   }
+
+   protected parse(text: string | null): WindowSession | undefined {
+      try {
+         const value: unknown = text ? JSON.parse(text) : undefined;
+         return isWindowSession(value) ? value : undefined;
+      } catch {
+         return undefined;
+      }
+   }
+}
+
+/**
+ * Bind {@link WindowSessionService} once per container, and claim it as the
+ * frontend starts. An adopter rebinds {@link WindowSessionService}.
+ */
+export function bindWindowSessionService(bind: interfaces.Bind, isBound: interfaces.IsBound): void {
+   if (!isBound(WindowSessionService)) {
+      bind(DefaultWindowSessionService).toSelf().inSingletonScope();
+      bind(WindowSessionService).toService(DefaultWindowSessionService);
+      bind(FrontendApplicationContribution).toService(WindowSessionService);
+   }
+}

package/src/node/glsp-server-connection-handler.ts

@@ -8,9 +8,7 @@
  ********************************************************************************/
 
 import { GLSPContribution } from '@eclipse-glsp/theia-integration/lib/common';
-import { SocketConnectionForwarder } from '@eclipse-glsp/theia-integration/lib/node';
-import { AbstractSocketForwardingConnectionHandler } from '@hydranium/client-theia/lib/node';
-import { type Channel, type Disposable } from '@theia/core';
+import { AbstractSocketForwardingConnectionHandler } from '@hydranium/client-theia/node';
 import { injectable, unmanaged } from '@theia/core/shared/inversify';
 import type * as net from 'net';
 
@@ -21,6 +19,8 @@ import type * as net from 'net';
 export interface GlspServerConnectionHandlerOptions {
    readonly languageContributionId: string;
    readonly portCommand: string;
+   /** Name of the server in this handler's log lines. */
+   readonly serverName?: string;
    readonly findPortTimeout?: number;
    readonly findPortAttempts?: number;
    readonly connectTimeoutMs?: number;
@@ -38,15 +38,13 @@ export interface GlspServerConnectionHandlerOptions {
 /**
  * Bridges a Theia browser-frontend channel to a GLSP server's TCP socket.
  *
- * The port-discovery + buffer-and-replay race fix + connect orchestration live
- * on the cross-head {@link AbstractSocketForwardingConnectionHandler} base; this
- * subclass supplies only the GLSP specifics — the per-language servicePath
+ * The port discovery, the buffer-and-replay race fix, the connect orchestration
+ * and the byte forwarder live on the cross-head
+ * {@link AbstractSocketForwardingConnectionHandler} base; this subclass supplies
+ * only the GLSP specifics — the per-language servicePath
  * (`GLSPContribution.servicePath + '/' + languageContributionId`), the port
- * command, the log labels — and plugs in `@eclipse-glsp/theia-integration`'s
- * `SocketConnectionForwarder` as the byte relay. Adopters with different
- * language ids or command names subclass with a one-line `super({...})` call.
- * Sibling of `@hydranium/data-client-theia`'s `DataServerConnectionHandler`,
- * which subclasses the same base with its own GLSP-free forwarder.
+ * command, the log labels. Adopters with different language ids or command
+ * names subclass with a one-line `super({...})` call.
  */
 @injectable()
 export class GlspServerConnectionHandler extends AbstractSocketForwardingConnectionHandler {
@@ -55,7 +53,7 @@ export class GlspServerConnectionHandler extends AbstractSocketForwardingConnect
          path: GLSPContribution.servicePath + '/' + options.languageContributionId,
          portCommand: options.portCommand,
          logComponent: 'GLSP',
-         serverName: 'Graphical Server',
+         serverName: options.serverName ?? 'Diagram Server',
          findPortTimeout: options.findPortTimeout,
          findPortAttempts: options.findPortAttempts,
          connectTimeoutMs: options.connectTimeoutMs,
@@ -63,7 +61,7 @@ export class GlspServerConnectionHandler extends AbstractSocketForwardingConnect
       });
    }
 
-   protected forwardToSocketConnection(clientChannel: Channel, socket: net.Socket): Disposable {
-      return new SocketConnectionForwarder(clientChannel, socket);
-   }
+   /** Logged only: the frontend contribution reports the failed start, and a
+    *  second notification would duplicate it. */
+   protected override reportConnectFailure(): void {}
 }

package/style/diagram-loading.css

@@ -49,11 +49,8 @@
    }
 }
 
-/* Failure state: set only when the loader could NOT dispatch its error
-   StatusAction, so this overlay is the single remaining surface for the message.
-   The spinner goes (nothing is pending any more) and the text takes the error
-   colour. A load that failed and WAS reported never reaches this state — the
-   overlay is removed and GLSP's own status overlay shows it instead. */
+/* Failure state: the spinner goes, since nothing is pending any more, and the
+   text takes the error colour. */
 .hydranium-diagram-loading-failed .hydranium-diagram-loading-spinner {
    display: none;
 }