@hydranium/data-client-theia 1.0.0-next.7 → 1.0.0-next.70

package/lib/browser/references-data-service-frontend.d.ts

@@ -1,45 +0,0 @@
-/********************************************************************************
- * 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 { FindNextNameArgs, ReferenceCandidate, ReferenceContext, ReferenceRequest, ReferenceServerProtocol, ReferenceTarget, TransferElement } from '@hydranium/protocol';
-import { AbstractDataServiceFrontend } from './data-service-frontend';
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also
- * composes the framework {@link ReferenceServerProtocol} fragment. It
- * implements each reference method as a readiness-gated pass-through —
- * `await this.ensureConnected()`, then delegate to `this.server` — so an
- * adopter frontend gets the candidate / resolve / next-name surface without
- * hand-writing identical one-liner bodies.
- *
- * The sibling of `AbstractDiagnosticsDataServiceFrontend`, and the same
- * shape for the same reason: `this.server` is already a forwarding proxy, but
- * it queues only on the channel being live, not on the server's `waitForReady`
- * gate — so the gate has to be interposed per method.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the
- * head's `DataServer` registers the reference fragment (typically via a
- * subclass's `additionalMethods`, since
- * `REFERENCE_SERVER_PROTOCOL_METHODS` is deliberately NOT part of
- * `DATA_SERVER_PROTOCOL_METHODS`). The `TServer` bound carries
- * `ReferenceServerProtocol`, so the delegates are type-checked without casts.
- *
- * A frontend needing both fragments extends the diagnostics base and mixes
- * these three in, or vice versa — TypeScript allows only one base class, so
- * the two bases are deliberately independent rather than chained. Chaining
- * them would force every reference-fragment adopter to also carry the
- * diagnostics surface, which a head that dropped those methods via
- * `DataServerOptions.excludedMethods` cannot satisfy.
- */
-export declare abstract class AbstractReferencesDataServiceFrontend<TTransfer extends TransferElement, TServer extends {
-    waitForReady(): Promise<void>;
-} & ReferenceServerProtocol<TTransfer>, TClient extends object> extends AbstractDataServiceFrontend<TServer, TClient> implements ReferenceServerProtocol<TTransfer> {
-    findReferenceCandidates(ctx: ReferenceContext): Promise<ReferenceCandidate[]>;
-    resolveReference(ref: ReferenceRequest): Promise<ReferenceTarget<TTransfer> | undefined>;
-    findNextName(args: FindNextNameArgs): Promise<string>;
-}
-//# sourceMappingURL=references-data-service-frontend.d.ts.map

package/lib/browser/references-data-service-frontend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"references-data-service-frontend.d.ts","sourceRoot":"","sources":["../../src/browser/references-data-service-frontend.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EACT,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,eAAe,EACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,8BAAsB,qCAAqC,CACxD,SAAS,SAAS,eAAe,EACjC,OAAO,SAAS;IAAE,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,GAAG,uBAAuB,CAAC,SAAS,CAAC,EACtF,OAAO,SAAS,MAAM,CAEtB,SAAQ,2BAA2B,CAAC,OAAO,EAAE,OAAO,CACpD,YAAW,uBAAuB,CAAC,SAAS,CAAC;IAEvC,uBAAuB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAK7E,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IAKxF,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;CAI7D"}

package/lib/browser/references-data-service-frontend.js

@@ -1,55 +0,0 @@
-"use strict";
-/********************************************************************************
- * 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
- ********************************************************************************/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractReferencesDataServiceFrontend = void 0;
-const data_service_frontend_1 = require("./data-service-frontend");
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also
- * composes the framework {@link ReferenceServerProtocol} fragment. It
- * implements each reference method as a readiness-gated pass-through —
- * `await this.ensureConnected()`, then delegate to `this.server` — so an
- * adopter frontend gets the candidate / resolve / next-name surface without
- * hand-writing identical one-liner bodies.
- *
- * The sibling of `AbstractDiagnosticsDataServiceFrontend`, and the same
- * shape for the same reason: `this.server` is already a forwarding proxy, but
- * it queues only on the channel being live, not on the server's `waitForReady`
- * gate — so the gate has to be interposed per method.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the
- * head's `DataServer` registers the reference fragment (typically via a
- * subclass's `additionalMethods`, since
- * `REFERENCE_SERVER_PROTOCOL_METHODS` is deliberately NOT part of
- * `DATA_SERVER_PROTOCOL_METHODS`). The `TServer` bound carries
- * `ReferenceServerProtocol`, so the delegates are type-checked without casts.
- *
- * A frontend needing both fragments extends the diagnostics base and mixes
- * these three in, or vice versa — TypeScript allows only one base class, so
- * the two bases are deliberately independent rather than chained. Chaining
- * them would force every reference-fragment adopter to also carry the
- * diagnostics surface, which a head that dropped those methods via
- * `DataServerOptions.excludedMethods` cannot satisfy.
- */
-class AbstractReferencesDataServiceFrontend extends data_service_frontend_1.AbstractDataServiceFrontend {
-    async findReferenceCandidates(ctx) {
-        await this.ensureConnected();
-        return this.server.findReferenceCandidates(ctx);
-    }
-    async resolveReference(ref) {
-        await this.ensureConnected();
-        return this.server.resolveReference(ref);
-    }
-    async findNextName(args) {
-        await this.ensureConnected();
-        return this.server.findNextName(args);
-    }
-}
-exports.AbstractReferencesDataServiceFrontend = AbstractReferencesDataServiceFrontend;
-//# sourceMappingURL=references-data-service-frontend.js.map

package/lib/browser/references-data-service-frontend.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"references-data-service-frontend.js","sourceRoot":"","sources":["../../src/browser/references-data-service-frontend.ts"],"names":[],"mappings":";AAAA;;;;;;;kFAOkF;;;AAWlF,mEAAsE;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAsB,qCAKnB,SAAQ,mDAA6C;IAGrD,KAAK,CAAC,uBAAuB,CAAC,GAAqB;QAChD,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC;IACnD,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,GAAqB;QACzC,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,IAAsB;QACtC,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;CACH;AAtBD,sFAsBC"}

package/src/browser/data-service-frontend.ts

@@ -1,208 +0,0 @@
-/********************************************************************************
- * 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 { createRpcProxy } from '@hydranium/protocol';
-import type { ServiceConnectionProvider } from '@theia/core/lib/browser';
-import { Deferred } from '@theia/core/lib/common/promise-util';
-import type { WorkspaceService } from '@theia/workspace/lib/browser';
-import type { MessageConnection } from 'vscode-jsonrpc';
-import { type ChannelConnectionHandle, openChannelConnection } from './channel-connection';
-import { whenWorkspaceOpen } from './workspace-gate';
-
-/**
- * Base for a Theia frontend that owns the data-server vscode-jsonrpc
- * connection directly (the data head's "frontend speaks the model-server's
- * protocol over a relayed channel" pattern). Lifts the mechanical wiring —
- * the workspace-gated connection, the combined server proxy + inbound client
- * binding, and the lazy idempotent init gate — leaving the adopter to supply
- * the connection seams and any progress UI / domain caching / request-method
- * delegation on top.
- *
- * Generic over the server protocol `TServer` (must expose `waitForReady`) and
- * the local notification target `TClient`. A subclass supplies the abstract
- * members below, calls {@link start} from its `@postConstruct`, and awaits
- * {@link ensureConnected} before its first `this.server.*` call.
- */
-export abstract class AbstractDataServiceFrontend<TServer extends { waitForReady(): Promise<void> }, TClient extends object> {
-   /**
-    * The workspace-gated connection to the backend forwarder. Set by
-    * {@link start}, and REPLACED whenever the connection is lost and
-    * {@link reconnectOnConnectionLoss} is on — so read it per use and never
-    * cache the resolved connection.
-    */
-   protected connectionPromise!: Promise<MessageConnection>;
-   /**
-    * Typed proxy over {@link connectionPromise}, addressing the server under
-    * {@link methodNamespace}. Set by {@link start}, and replaced alongside
-    * {@link connectionPromise} on reconnect.
-    *
-    * `createRpcProxy` resolves the connection promise once and binds to it for
-    * good, so a reconnect necessarily means a new proxy. Reading
-    * `this.server.foo()` per call — rather than hoisting `this.server` into a
-    * local or a constructor-time field — is what keeps a subclass correct
-    * across one.
-    */
-   protected server!: TServer;
-   /** The channel handle {@link start} opened; owns reconnect and disposal. */
-   protected channel?: ChannelConnectionHandle;
-   /** Shared init Deferred so concurrent {@link ensureConnected} callers await one initialization. */
-   protected initialized?: Deferred<void>;
-
-   /** Theia connection provider the channel is opened through. */
-   protected abstract readonly connectionProvider: ServiceConnectionProvider;
-   /**
-    * Optional workspace service. When provided, the default
-    * {@link connectionReadyGate} waits for a workspace before opening the
-    * channel; a head that is not workspace-scoped omits it (and may override
-    * {@link connectionReadyGate} for a different gate).
-    */
-   protected abstract readonly workspaceService?: WorkspaceService;
-   /** Local inbound-notification target bound on the connection (the `localTarget`). */
-   protected abstract readonly client: TClient;
-   /**
-    * Theia service path the backend forwarder is registered under.
-    *
-    * **Unique per frontend, not per server.** Theia keys a frontend channel by
-    * this path and throws `Another channel with the id '<path>' is already open`
-    * on a second opener — so a subclass sharing the framework default with any
-    * other consumer of the same head (a host-neutral `DataPort`, a sibling
-    * service frontend) breaks whichever opens second. The failure is remote from
-    * its cause: the throw escapes an `openChannelConnection` the other consumer
-    * awaited, leaving its request permanently unsettled rather than rejected,
-    * which presents as a view stuck on its loading state with a clean server
-    * log. Give each frontend its own path and register a forwarder per path;
-    * they still reach one server, since the shared `portCommand` is what names
-    * the process.
-    */
-   protected abstract readonly servicePath: string;
-   /** Wire namespace the server + client methods are addressed under. */
-   protected abstract readonly methodNamespace: string;
-   /** Allowlist of {@link client} methods to bind as inbound handlers. */
-   protected abstract readonly clientMethods: readonly (keyof TClient & string)[];
-
-   /**
-    * Rebuild the connection and the proxy when the current connection is lost,
-    * and re-run initialization against the replacement. Defaults to `true` —
-    * see `OpenChannelConnectionOptions.reconnect` for why re-opening the
-    * channel is the only thing that recovers a restarted language server, and
-    * why a dead connection leaves no alternative worth preserving.
-    *
-    * The subclass-facing cost is that {@link doInitialize} runs again per
-    * connection, so any progress UI it drives reappears. Turn this off for a
-    * frontend that would rather show nothing than show its warm-up twice, or
-    * that tears itself down on transport loss.
-    */
-   protected readonly reconnectOnConnectionLoss: boolean = true;
-
-   /**
-    * Readiness gate for the connection — the channel opens only once the
-    * returned promise settles. Default: waits for a workspace when
-    * {@link workspaceService} is provided, otherwise opens immediately
-    * (`undefined`). Override for a different gate (e.g. a fixed model store
-    * that is always ready, or a custom warm-up).
-    */
-   protected connectionReadyGate(): Promise<void> | undefined {
-      return this.workspaceService ? whenWorkspaceOpen(this.workspaceService) : undefined;
-   }
-
-   /**
-    * Open the connection (workspace-gated by default via
-    * {@link connectionReadyGate}) and build the combined server proxy +
-    * inbound client binding. Call once (typically from the adopter's
-    * `@postConstruct`). Outbound calls + inbound notifications queue over the
-    * connection promise until the channel is live.
-    */
-   protected start(): void {
-      this.channel = openChannelConnection(this.connectionProvider, this.servicePath, {
-         whenReady: this.connectionReadyGate(),
-         reconnect: this.reconnectOnConnectionLoss
-      });
-      this.bindConnection();
-      // The LOSS, not the replacement's arrival: rebinding when the channel
-      // closes points `server` at the queueing replacement promise, so a request
-      // made during the gap waits for the new server instead of being addressed
-      // at the dead one and never settling.
-      this.channel.onDidLoseConnection(() => this.handleConnectionLost());
-   }
-
-   /**
-    * Point {@link connectionPromise} and {@link server} at the channel's
-    * current connection. Called by {@link start} and again per reconnect.
-    */
-   protected bindConnection(): void {
-      if (!this.channel) {
-         throw new Error('bindConnection called before start');
-      }
-      this.connectionPromise = this.channel.current;
-      this.server = createRpcProxy<TServer, TClient>(this.connectionPromise, {
-         methodNamespace: this.methodNamespace,
-         localTarget: this.client,
-         localMethods: this.clientMethods
-      });
-   }
-
-   /**
-    * Rebind onto the replacement connection and arm initialization to run again.
-    *
-    * Clearing {@link initialized} is the load-bearing half. A restarted server
-    * has an unwarmed workspace, so its `waitForReady` gate has to be awaited
-    * afresh; leaving the old resolved Deferred in place would let the first
-    * request after a restart through against a server still walking the
-    * workspace, and be answered correctly from an empty registry — which reads
-    * as data loss rather than as a race.
-    */
-   protected handleConnectionLost(): void {
-      this.initialized = undefined;
-      this.bindConnection();
-   }
-
-   /**
-    * Release the connection and stop tracking the channel. Idempotent.
-    *
-    * Subclasses that are Theia `Disposable`s should route their own disposal
-    * here; nothing calls it automatically, because the base is not bound to a
-    * lifecycle of its own.
-    */
-   dispose(): void {
-      this.channel?.dispose();
-      this.channel = undefined;
-      this.initialized = undefined;
-   }
-
-   /**
-    * Lazily drive initialization, shared across concurrent callers via one
-    * {@link Deferred}. Request methods `await this.ensureConnected()` before
-    * their first `this.server.*` call.
-    */
-   protected ensureConnected(): Promise<void> {
-      if (!this.initialized) {
-         this.initialized = new Deferred<void>();
-         void this.doInitialize(this.initialized);
-      }
-      return this.initialized.promise;
-   }
-
-   /**
-    * Default initialization: await the connection, await the server's readiness
-    * gate, then resolve the passed Deferred. Initialization completion is
-    * observable by awaiting {@link ensureConnected} (which returns this same
-    * Deferred's promise) — there is no separate post-init hook. Override
-    * wholesale to interleave progress UI / extra warm-up; an override owns
-    * resolving/rejecting `initialized` (there is no `super` step to call).
-    */
-   protected async doInitialize(initialized: Deferred<void>): Promise<void> {
-      try {
-         await this.connectionPromise;
-         await this.server.waitForReady();
-         initialized.resolve();
-      } catch (error) {
-         initialized.reject(error instanceof Error ? error : new Error(String(error)));
-      }
-   }
-}

package/src/browser/diagnostics-data-service-frontend.ts

@@ -1,70 +0,0 @@
-/********************************************************************************
- * 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 {
-   DataServerDiagnosticsProtocol,
-   DumpServerStateArgs,
-   LatencyReport,
-   StartProfilingArgs,
-   StopProfilingArgs,
-   WriteServerHeapSnapshotArgs
-} from '@hydranium/protocol';
-import { AbstractDataServiceFrontend } from './data-service-frontend';
-
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also exposes
- * the framework {@link DataServerDiagnosticsProtocol} (which the framework
- * `DataServer` implements by default). It implements each diagnostics method as
- * a readiness-gated pass-through — `await this.ensureConnected()`, then delegate
- * to `this.server` — so every adopter frontend gets the memory / state /
- * profiling / latency surface without hand-writing identical one-liner bodies.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the head's
- * `DataServer` keeps the default diagnostics registration; the `TServer` bound
- * carries `DataServerDiagnosticsProtocol`, so the delegates are type-checked
- * (no casts). A head that dropped the diagnostics methods via
- * `DataServerOptions.excludedMethods` should extend the plain base instead.
- */
-export abstract class AbstractDiagnosticsDataServiceFrontend<
-   TServer extends { waitForReady(): Promise<void> } & DataServerDiagnosticsProtocol,
-   TClient extends object
->
-   extends AbstractDataServiceFrontend<TServer, TClient>
-   implements DataServerDiagnosticsProtocol
-{
-   async dumpServerState(args: DumpServerStateArgs): Promise<string> {
-      await this.ensureConnected();
-      return this.server.dumpServerState(args);
-   }
-
-   async writeHeapSnapshot(args: WriteServerHeapSnapshotArgs): Promise<string> {
-      await this.ensureConnected();
-      return this.server.writeHeapSnapshot(args);
-   }
-
-   async dumpPodMemory(): Promise<string> {
-      await this.ensureConnected();
-      return this.server.dumpPodMemory();
-   }
-
-   async startProfiling(args: StartProfilingArgs): Promise<void> {
-      await this.ensureConnected();
-      return this.server.startProfiling(args);
-   }
-
-   async stopProfiling(args: StopProfilingArgs): Promise<string> {
-      await this.ensureConnected();
-      return this.server.stopProfiling(args);
-   }
-
-   async getLatency(): Promise<LatencyReport> {
-      await this.ensureConnected();
-      return this.server.getLatency();
-   }
-}

package/src/browser/references-data-service-frontend.ts

@@ -1,70 +0,0 @@
-/********************************************************************************
- * 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 {
-   FindNextNameArgs,
-   ReferenceCandidate,
-   ReferenceContext,
-   ReferenceRequest,
-   ReferenceServerProtocol,
-   ReferenceTarget,
-   TransferElement
-} from '@hydranium/protocol';
-import { AbstractDataServiceFrontend } from './data-service-frontend';
-
-/**
- * {@link AbstractDataServiceFrontend} specialised for a server that also
- * composes the framework {@link ReferenceServerProtocol} fragment. It
- * implements each reference method as a readiness-gated pass-through —
- * `await this.ensureConnected()`, then delegate to `this.server` — so an
- * adopter frontend gets the candidate / resolve / next-name surface without
- * hand-writing identical one-liner bodies.
- *
- * The sibling of `AbstractDiagnosticsDataServiceFrontend`, and the same
- * shape for the same reason: `this.server` is already a forwarding proxy, but
- * it queues only on the channel being live, not on the server's `waitForReady`
- * gate — so the gate has to be interposed per method.
- *
- * Extend this instead of {@link AbstractDataServiceFrontend} whenever the
- * head's `DataServer` registers the reference fragment (typically via a
- * subclass's `additionalMethods`, since
- * `REFERENCE_SERVER_PROTOCOL_METHODS` is deliberately NOT part of
- * `DATA_SERVER_PROTOCOL_METHODS`). The `TServer` bound carries
- * `ReferenceServerProtocol`, so the delegates are type-checked without casts.
- *
- * A frontend needing both fragments extends the diagnostics base and mixes
- * these three in, or vice versa — TypeScript allows only one base class, so
- * the two bases are deliberately independent rather than chained. Chaining
- * them would force every reference-fragment adopter to also carry the
- * diagnostics surface, which a head that dropped those methods via
- * `DataServerOptions.excludedMethods` cannot satisfy.
- */
-export abstract class AbstractReferencesDataServiceFrontend<
-   TTransfer extends TransferElement,
-   TServer extends { waitForReady(): Promise<void> } & ReferenceServerProtocol<TTransfer>,
-   TClient extends object
->
-   extends AbstractDataServiceFrontend<TServer, TClient>
-   implements ReferenceServerProtocol<TTransfer>
-{
-   async findReferenceCandidates(ctx: ReferenceContext): Promise<ReferenceCandidate[]> {
-      await this.ensureConnected();
-      return this.server.findReferenceCandidates(ctx);
-   }
-
-   async resolveReference(ref: ReferenceRequest): Promise<ReferenceTarget<TTransfer> | undefined> {
-      await this.ensureConnected();
-      return this.server.resolveReference(ref);
-   }
-
-   async findNextName(args: FindNextNameArgs): Promise<string> {
-      await this.ensureConnected();
-      return this.server.findNextName(args);
-   }
-}