@hydranium/glsp-client-theia 1.0.0-next.33 → 1.0.0-next.331

package/src/browser/hidden-bounds-updater.ts

@@ -1,212 +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 Action,
-   type ElementAndRoutingPoints,
-   type GModelElement,
-   type GRoutableElement,
-   GLSPHiddenBoundsUpdater,
-   type LocalRequestBoundsAction,
-   Point,
-   RequestBoundsAction,
-   ServerAction,
-   isRoutable
-} from '@eclipse-glsp/client';
-import { ChannelLogger } from '@hydranium/client-theia/lib/browser';
-import { type Clock, SystemClock } from '@hydranium/protocol';
-import { inject, injectable } from '@theia/core/shared/inversify';
-import { type VNode } from 'snabbdom';
-
-/** How many scoped element ids the log line names before summarising the rest.
- *  A scoped request names one element in practice; the cap only stops a
- *  pathological caller from writing a thousand ids into the channel. */
-const SCOPE_ID_CAP = 3;
-
-/**
- * Instruments sprotty's hidden-bounds pass and repairs degenerate routes before
- * they go on the wire.
- *
- * **Why the framework owns this.** Every GLSP head runs the hidden-bounds pass on
- * every model update, and it is the one client-side phase that scales with the
- * *rendered element count* rather than the model size — labels, compartments and
- * edge decorations expand a modest node count into orders of magnitude more DOM
- * elements. Without a timing line there is no way to tell a slow measurement pass
- * apart from slow edge routing or a slow server round trip; with one,
- * `bounds-request` either exonerates the client in a sentence or names the
- * dominant cost.
- *
- * Emits exactly one `trace` line per bounds request — `trace` because the
- * frequency matches the per-action traffic `HydraniumGlspActionDispatcher` logs
- * there (a bounds request is driven by those actions), so it belongs with them
- * rather than above them. The line carries:
- *
- *  - `server` / `local` — whether the request came from the server or from a
- *    client-local {@link LocalRequestBoundsAction}
- *  - `scope=<ids>` — the elements a scoped request named; absent when the request
- *    covers the whole diagram
- *  - `measured=N` — DOM elements whose bounds were read. Exceeds the scoped id
- *    count because the base class expands each requested element to its
- *    descendants
- *  - `getBBox=Nms` — {@link getBoundsFromDOM} **only**: the layout pass and the
- *    `ComputedBoundsAction` assembly stay outside it, so the number isolates raw
- *    measurement cost
- *
- * Composed from {@link Clock.measure} rather than `Tracer.time`, matching
- * `HydraniumDocumentBuilder`'s phase instrumentation. `Tracer.time` is for "tell
- * me when this is slow" and is deliberately silent on a fast success, which would
- * drop the element count on every normal pass — and forcing it to emit costs a
- * paired `[#N start]` line per request. This is a per-occurrence record, so it
- * measures and composes its own line.
- *
- * Bound by `createGlspClientTheiaModule` via `rebind(GLSPHiddenBoundsUpdater)`.
- */
-@injectable()
-export class HydraniumHiddenBoundsUpdater extends GLSPHiddenBoundsUpdater {
-   @inject(ChannelLogger) protected readonly channel!: ChannelLogger;
-
-   /** Not injected: the browser container binds no {@link Clock}, and this only
-    *  measures — no logic is gated on time, so there is nothing to fake in
-    *  production. Overridden in tests for a deterministic elapsed value. */
-   protected readonly clock: Clock = new SystemClock();
-
-   /**
-    * Scope description for the in-flight request, read from the `cause` in
-    * {@link postUpdate} and consumed by {@link getBoundsFromDOM} — which the base
-    * class calls with no arguments, so the cause cannot be threaded through.
-    */
-   protected currentScope?: string;
-
-   override decorate(vnode: VNode, element: GModelElement): VNode {
-      super.decorate(vnode, element);
-      if (isRoutable(element)) {
-         this.repairLastRoute(element);
-      }
-      return vnode;
-   }
-
-   /**
-    * Replace the routing entry the base class just pushed when it carries fewer
-    * than two points, which is not a valid route for any edge.
-    *
-    * `calcElementAndRoute` already guards the case where the registered router
-    * returns *nothing* — it falls back to source + own routing points + target.
-    * The hole is one step further in: `calcRoute` filters duplicate points at
-    * `Number.EPSILON`, so while obstacles still carry sprotty's unmeasured-bounds
-    * sentinel `(100, 100, -1, -1)` the source and target coincide and a valid
-    * two-point route collapses to a single point. That result is defined, so the
-    * upstream truthiness guard never fires and the single point ships.
-    *
-    * The substitute is deliberately upstream's own fallback shape rather than a
-    * new invention, so a repaired route is indistinguishable from a route the
-    * base class would have produced had it noticed. Only already-invalid payloads
-    * are touched, so a head with a working router is unaffected.
-    */
-   protected repairLastRoute(element: GRoutableElement): void {
-      const addedRoute = this.element2route.pop();
-      if (addedRoute === undefined) {
-         return;
-      }
-      this.element2route.push(this.hasValidRoute(addedRoute) ? addedRoute : this.toSourceTargetRoute(element));
-   }
-
-   /** A route needs at least a start and an end point to describe an edge. */
-   protected hasValidRoute(route: ElementAndRoutingPoints): boolean {
-      return route.newRoutingPoints !== undefined && route.newRoutingPoints.length >= 2;
-   }
-
-   /** Upstream's `calcElementAndRoute` no-router fallback: the element's own
-    *  bendpoints framed by its source and target anchor positions. */
-   protected toSourceTargetRoute(element: GRoutableElement): ElementAndRoutingPoints {
-      return {
-         elementId: element.id,
-         newRoutingPoints: [element.source?.position ?? Point.ORIGIN, ...element.routingPoints, element.target?.position ?? Point.ORIGIN]
-      };
-   }
-
-   protected override getBoundsFromDOM(): void {
-      if (this.currentScope === undefined) {
-         // Not inside an instrumented `postUpdate` (a subclass calling directly);
-         // with no cause there is nothing to attribute a measurement to.
-         super.getBoundsFromDOM();
-         return;
-      }
-      // Read before the pass: the base class clears the map on its way out.
-      const measured = this.getElement2BoundsData().size;
-      const { elapsedMs } = this.clock.measure(() => super.getBoundsFromDOM());
-      this.channel.trace(this.formatBoundsRequest(this.currentScope, measured, elapsedMs));
-   }
-
-   /** Format the per-request line. Override to change the wording. */
-   protected formatBoundsRequest(scope: string, measured: number, elapsedMs: number): string {
-      return `bounds-request[${scope}] measured=${measured} getBBox=${elapsedMs.toFixed(0)}ms`;
-   }
-
-   override postUpdate(cause?: Action): void {
-      if (cause?.kind !== RequestBoundsAction.KIND) {
-         super.postUpdate(cause);
-         return;
-      }
-      this.currentScope = this.formatCause(cause);
-      try {
-         super.postUpdate(cause);
-      } finally {
-         this.currentScope = undefined;
-      }
-   }
-
-   /**
-    * Scope facts for the log line: where the request came from, and which
-    * elements it asked for.
-    *
-    * Origin is read from {@link ServerAction}, the `__receivedFromServer` marker
-    * `GLSPModelSource` stamps on inbound actions, rather than from
-    * `LocalRequestBoundsAction.is`. The latter would answer the same today, but
-    * only incidentally: its `elementIDs` check is declared optional, so it is
-    * really just "a bounds request that did not come from the server". Keying on
-    * the marker states that directly, and keeps an *unscoped* local request from
-    * being mislabelled `server` if GLSP ever tightens that guard.
-    */
-   protected formatCause(cause: Action): string {
-      const origin = ServerAction.is(cause) ? 'server' : 'local';
-      const scope = this.formatScope(cause as RequestBoundsAction);
-      return scope ? `${origin} scope=${scope}` : origin;
-   }
-
-   /**
-    * Name the elements a scoped request asked for, or `undefined` when it covers
-    * the whole diagram.
-    *
-    * Deliberately the ids and not their count. A scoped request in practice names
-    * a single element, so a count is always `1` and says nothing, while the id
-    * says *which* element was re-measured — and it is the only part of the line
-    * that distinguishes one such request from the next. It also stops the line
-    * reading as a contradiction: `scope=node0, measured=6` is coherent (the base
-    * class expands a requested element to its descendants, so one id measures six
-    * DOM elements), where `scoped=1, measured=6` invites the reader to wonder
-    * which number is wrong.
-    *
-    * A request naming only the root is treated as unscoped: it measures
-    * everything, so the id adds nothing over the absence of a `scope` tag.
-    */
-   protected formatScope(cause: RequestBoundsAction): string | undefined {
-      const scopedIds = (cause as LocalRequestBoundsAction).elementIDs;
-      if (!scopedIds || scopedIds.length === 0) {
-         return undefined;
-      }
-      const named = scopedIds.filter(id => id !== cause.newRoot?.id);
-      if (named.length === 0) {
-         return undefined;
-      }
-      if (named.length > SCOPE_ID_CAP) {
-         return `${named.slice(0, SCOPE_ID_CAP).join(',')},+${named.length - SCOPE_ID_CAP} more`;
-      }
-      return named.join(',');
-   }
-}

package/src/testing/bind-recorder.ts

@@ -1,126 +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 { interfaces } from 'inversify';
-
-/**
- * One captured `bind(...)` or `rebind(...)` call on a {@link BindRecorder}.
- *
- * `chain` holds the follow-up methods in invocation order, one string per call,
- * rendered as `name(arg, …)`. Arguments are stringified inline so assertions
- * can compare structure without re-resolving service identifiers.
- */
-export interface BindRecorderEntry {
-   readonly kind: 'bind' | 'rebind';
-   readonly token: unknown;
-   readonly chain: string[];
-}
-
-/**
- * A spy set of Inversify binding hooks that records every call and its chain.
- * Hand them to a module-factory under test — they satisfy Inversify's
- * `interfaces.Bind` / `interfaces.Rebind` / `interfaces.Unbind` /
- * `interfaces.IsBound` shapes at the call site but never resolve real services.
- *
- * Together they match GLSP's `BindingContext`, so a factory taking the whole
- * context is called as `factory(recorder, options)` — the recorder *is*
- * structurally a context.
- *
- * Use {@link captured} to assert which tokens were touched and with what
- * fluent chain. {@link find} is a small ergonomic helper for the common
- * lookup pattern.
- */
-export interface BindRecorder {
-   readonly bind: interfaces.Bind;
-   readonly rebind: interfaces.Rebind;
-   readonly unbind: interfaces.Unbind;
-   readonly isBound: interfaces.IsBound;
-   readonly captured: readonly BindRecorderEntry[];
-   /** Convenience lookup — returns the first entry matching both `kind` and `token`, or `undefined`. */
-   find(kind: 'bind' | 'rebind', token: unknown): BindRecorderEntry | undefined;
-}
-
-/** Options for {@link makeBindRecorder}. */
-export interface BindRecorderOptions {
-   /**
-    * What `isBound` answers. Defaults to `true` for every token, matching
-    * production: a head registers its own module *after* the GLSP default
-    * modules, so the tokens a framework module rebinds are already bound. Pass a
-    * list to model a container where only those tokens are bound — e.g. to
-    * exercise a factory's bind-instead-of-rebind fallback.
-    */
-   readonly boundTokens?: readonly unknown[];
-}
-
-/** Methods on Inversify's binding builder that the recorder traps verbatim. */
-const RECORDED_CHAIN_METHODS = [
-   'toSelf',
-   'to',
-   'toService',
-   'toConstantValue',
-   'toDynamicValue',
-   'toFactory',
-   'toFunction',
-   'toAutoFactory',
-   'toProvider',
-   'inSingletonScope',
-   'inTransientScope',
-   'inRequestScope',
-   'whenTargetNamed',
-   'whenTargetTagged',
-   'whenInjectedInto',
-   'onActivation',
-   'onDeactivation'
-] as const;
-
-/**
- * Build a {@link BindRecorder} for testing Inversify module factories without a
- * real container: hand it to the factory, then assert over {@link BindRecorder.find}.
- *
- * The `bind` / `rebind` functions return a chained proxy that ignores its
- * arguments structurally but records every method invocation as a string.
- * Stringification: functions → `<className>`, symbols → `Symbol(desc).toString()`,
- * everything else → `String(value)`. This is enough to assert which tokens are
- * involved without dragging real service resolution into the test.
- */
-export function makeBindRecorder(options: BindRecorderOptions = {}): BindRecorder {
-   const captured: BindRecorderEntry[] = [];
-
-   const stringifyArg = (value: unknown): string => {
-      if (typeof value === 'function') {
-         return `<${value.name || 'fn'}>`;
-      }
-      if (typeof value === 'symbol') {
-         return value.toString();
-      }
-      return String(value);
-   };
-
-   const beginEntry = (kind: 'bind' | 'rebind', token: unknown): unknown => {
-      const entry: BindRecorderEntry = { kind, token, chain: [] };
-      captured.push(entry);
-      const proxy: Record<string, (...args: unknown[]) => unknown> = {};
-      for (const method of RECORDED_CHAIN_METHODS) {
-         proxy[method] = (...args: unknown[]): unknown => {
-            entry.chain.push(`${method}(${args.map(stringifyArg).join(', ')})`);
-            return proxy;
-         };
-      }
-      return proxy;
-   };
-
-   const bind = ((token: unknown) => beginEntry('bind', token)) as interfaces.Bind;
-   const rebind = ((token: unknown) => beginEntry('rebind', token)) as interfaces.Rebind;
-   const unbind = (() => undefined) as unknown as interfaces.Unbind;
-   const isBound = ((token: unknown) => options.boundTokens?.includes(token) ?? true) as interfaces.IsBound;
-   const find = (kind: 'bind' | 'rebind', token: unknown): BindRecorderEntry | undefined =>
-      captured.find(entry => entry.kind === kind && entry.token === token);
-
-   return { bind, rebind, unbind, isBound, captured, find };
-}

package/src/testing/index.ts

@@ -1,15 +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
- ********************************************************************************/
-
-// Subpath barrel for `@hydranium/glsp-client-theia/testing` — the
-// GLSP-module-specific Inversify test double. The cross-head doubles
-// (`makeStubOutputChannelManager`, `makeStubInversifyContext`) live in
-// `@hydranium/client-theia/testing`, alongside the logger they double for.
-
-export * from './bind-recorder';