@memberjunction/ng-conversations 5.40.1 → 5.41.0

package/dist/lib/components/realtime/remote-browser/remote-browser-surface.component.d.ts

@@ -0,0 +1,346 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/** A keyboard modifier held during a relayed human input (Shift-click selection, Ctrl/Cmd+key chords). */
+export type RemoteBrowserModifier = 'Shift' | 'Control' | 'Alt' | 'Meta';
+/**
+ * One human-takeover input the surface emits to the channel while the user "drives" the live view.
+ * Mirrors the server's `RemoteBrowserHumanInput` union (flattened for transport): pointer
+ * moves/clicks/down/up and scrolls carry VIEWPORT coordinates, a scroll also carries wheel deltas, a key
+ * carries the pressed key string. Pointer clicks/down/up and keys also carry any held `modifiers`.
+ */
+export interface RemoteBrowserHumanInputEvent {
+    /** Which input occurred. */
+    kind: 'pointer-move' | 'pointer-click' | 'pointer-down' | 'pointer-up' | 'key' | 'scroll';
+    /** Viewport X (pointer + scroll kinds only). */
+    x?: number;
+    /** Viewport Y (pointer + scroll kinds only). */
+    y?: number;
+    /** Mouse button (pointer-click / -down / -up only). */
+    button?: 'left' | 'middle' | 'right';
+    /** The pressed key (key kind only). */
+    key?: string;
+    /** Horizontal wheel delta in pixels (scroll kind only; positive = right). */
+    deltaX?: number;
+    /** Vertical wheel delta in pixels (scroll kind only; positive = down). */
+    deltaY?: number;
+    /** Modifier keys held during the input (pointer-click / -down / -up and key kinds). */
+    modifiers?: RemoteBrowserModifier[];
+}
+/**
+ * Maps a display-space pointer position on the live canvas to the server browser's VIEWPORT pixel space.
+ *
+ * The canvas's internal resolution (`canvasWidth`/`canvasHeight`, set from each pushed frame) IS the
+ * viewport pixel space; the canvas is displayed scaled to its bounding rect. So a display point maps as
+ * `vx = (clientX - rect.left) / rect.width * canvasWidth` (and likewise for y), rounded to ints. Returns
+ * `null` for a zero-size rect or un-sized canvas (divide-by-zero / not-ready guard).
+ *
+ * Pure + framework-free so it's unit-testable without a DOM.
+ *
+ * @param clientX The pointer's viewport X in the DOM (`event.clientX`).
+ * @param clientY The pointer's viewport Y in the DOM (`event.clientY`).
+ * @param rect The canvas's bounding rect (`getBoundingClientRect()`).
+ * @param canvasWidth The canvas's internal pixel width (= frame/viewport width).
+ * @param canvasHeight The canvas's internal pixel height (= frame/viewport height).
+ * @returns Integer viewport coordinates, or `null` when mapping isn't possible.
+ */
+export declare function MapToViewportCoords(clientX: number, clientY: number, rect: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, canvasWidth: number, canvasHeight: number): {
+    x: number;
+    y: number;
+} | null;
+/**
+ * One snapshot of the server-hosted browser — the shape the surface's {@link RemoteBrowserSurfaceComponent.Fetch}
+ * callback resolves to. Mirrors the server's `RemoteBrowserSnapshot` query payload.
+ */
+export interface RemoteBrowserSnapshotView {
+    /** The current page screenshot as raw base64 PNG, or `null` when none is available yet. */
+    ScreenshotBase64: string | null;
+    /** The current page URL, or `null` when no page is loaded. */
+    CurrentUrl: string | null;
+}
+/**
+ * Fetches one {@link RemoteBrowserSnapshotView} from the server. Supplied by the channel
+ * plugin (it owns the session id + GraphQL provider). Best-effort by contract: resolves to
+ * `null` on any failure rather than throwing, so the surface keeps the last good frame.
+ */
+export type RemoteBrowserSnapshotFetcher = () => Promise<RemoteBrowserSnapshotView | null>;
+/**
+ * LIVE REMOTE-BROWSER surface (`mj-realtime-remote-browser-surface`) — the Browser channel
+ * tab's pane. It renders the SERVER-hosted browser the agent drives: a refreshing screenshot
+ * `<img>` with the current URL above it and a small "live" indicator. The agent's
+ * `browser_*` tools mutate the page through the channel plugin; this surface only PERCEIVES
+ * it, polling its {@link Fetch} callback every {@link SNAPSHOT_POLL_MS} ms while bound.
+ *
+ * The surface is transport-agnostic — it never touches GraphQL directly. The channel plugin
+ * wires the {@link Fetch} callback (closing over the session id + provider) in `BindSurface`
+ * before the surface's first change detection, so the `ngOnInit` poll has it. Polling stops
+ * in `ngOnDestroy` (pane collapsed / overlay torn down) so no traffic continues after unbind.
+ * View-only in v1 — there is no takeover input.
+ *
+ * ### Two render paths: pushed screencast (preferred) vs. snapshot poll (fallback)
+ * When the backend advertises the `ScreenStreaming` capability, the server PUSHES encoded CDP
+ * frames and the channel plugin sets {@link Streaming} = `true`. In that mode the surface paints
+ * each frame onto a `<canvas>` via {@link RenderFrame} and DOES NOT start the poll. When streaming
+ * is off (capability absent or start failed) the original behavior is unchanged: the surface polls
+ * {@link Fetch} every {@link SNAPSHOT_POLL_MS} ms and renders the screenshot `<img>`.
+ */
+export declare class RemoteBrowserSurfaceComponent implements OnInit, OnDestroy {
+    /** Snapshot fetcher supplied by the channel plugin (closes over the session id + provider). */
+    Fetch: RemoteBrowserSnapshotFetcher | null;
+    /**
+     * Whether the server is PUSHING live screencast frames for this session (the backend advertised the
+     * `ScreenStreaming` capability and the start succeeded). When `true` the surface paints pushed frames
+     * onto its `<canvas>` via {@link RenderFrame} and does NOT poll; when `false` it uses the snapshot
+     * `<img>` poll fallback. Set by the channel plugin in `BindSurface` from the start-screencast result.
+     *
+     * The start-screencast result is async, so this may flip to `true` AFTER `ngOnInit` has already begun
+     * polling — the setter tears the poll down in that case so the two render paths never run at once.
+     */
+    set Streaming(value: boolean);
+    get Streaming(): boolean;
+    private _streaming;
+    /**
+     * Whether HUMAN TAKEOVER is enabled — the user watching the live view can click/type into the page and
+     * those events are relayed into the server browser (Collaborative control). Takeover only attaches to the
+     * canvas render path (pushed screencast); the `<img>` poll fallback stays view-only. When enabled while
+     * already streaming the setter attaches listeners; flipping it off (or streaming off) detaches them.
+     */
+    set Interactive(value: boolean);
+    get Interactive(): boolean;
+    private _interactive;
+    /** Emits each human-takeover input (pointer move/click, key) the user performs on the live canvas. */
+    HumanInput: EventEmitter<RemoteBrowserHumanInputEvent>;
+    /**
+     * Whether the live tab-audio stream is available — the channel sets this `true` when the server confirms
+     * it is pushing audio. Drives whether the speaker toggle renders in the live-view bar.
+     */
+    AudioAvailable: boolean;
+    /**
+     * Whether tab audio is currently muted. Two-way: the channel sets the initial value (un-muted when audio
+     * starts) and the toggle updates it; {@link AudioMutedChange} relays each user change to the channel,
+     * which mutes/unmutes the player.
+     */
+    AudioMuted: boolean;
+    /** Emits the new muted state each time the user toggles the speaker (two-way `AudioMuted`). */
+    AudioMutedChange: EventEmitter<boolean>;
+    /** Toggles the speaker mute state and relays it to the channel (which mutes/unmutes the audio player). */
+    ToggleAudioMuted(): void;
+    /** True when takeover is both enabled AND on the canvas path — drives the cursor + "driving" pill. */
+    get CanTakeOver(): boolean;
+    /**
+     * True while the user is actively driving the remote browser with the keyboard — the takeover canvas
+     * holds focus. The host overlay reads this to stand down its own global keyboard shortcuts (e.g.
+     * T-to-type opening the local composer) so keystrokes go to the remote page, not the local input.
+     */
+    get IsCapturingInput(): boolean;
+    /** The current screenshot as a `data:` URL, or `null` before the first snapshot arrives. */
+    ScreenshotDataUrl: string | null;
+    /** The current page URL reported by the server, or `null` when none. */
+    CurrentUrl: string | null;
+    /** Whether at least one pushed screencast frame has been painted (drives the canvas placeholder). */
+    HasFrame: boolean;
+    /** The canvas the pushed screencast frames are painted onto (present only while {@link Streaming}). */
+    private frameCanvas?;
+    /** The transparent overlay the synthetic cursor is drawn onto (present only while {@link CanTakeOver}). */
+    private cursorCanvas?;
+    /** Whether at least one screenshot OR frame has been rendered (drives the "Live" indicator). */
+    get HasSnapshot(): boolean;
+    private readonly cdr;
+    private readonly zone;
+    /** Active poll timer; `null` when polling is stopped. */
+    private pollTimer;
+    /** Guards against overlapping polls when a request runs longer than the interval. */
+    private polling;
+    /** Set on destroy so an in-flight poll's late resolution doesn't touch a torn-down view. */
+    private destroyed;
+    /** Reused decode target for pushed frames — avoids allocating an `Image` per frame. */
+    private readonly frameImage;
+    /** The most recent un-painted frame data URL, drained on the next animation frame (drop-old coalescing). */
+    private pendingFrameDataUrl;
+    /** True while a paint is scheduled, so rapid frames coalesce to one `requestAnimationFrame`. */
+    private framePaintScheduled;
+    /** The canvas element takeover listeners are currently bound to, or `null` when detached. */
+    private takeoverCanvas;
+    /** Timestamp (ms) of the last forwarded pointer-move, for throttling the high-frequency stream. */
+    private lastPointerMoveAt;
+    /** Timestamp (ms) of the last forwarded scroll, for throttling the high-frequency wheel stream. */
+    private lastScrollAt;
+    /** Horizontal wheel delta accumulated since the last forwarded scroll (coalesced across throttled events). */
+    private pendingScrollDeltaX;
+    /** Vertical wheel delta accumulated since the last forwarded scroll (coalesced across throttled events). */
+    private pendingScrollDeltaY;
+    /** Last canvas-relative mouse position in VIEWPORT pixel space, or `null` when the pointer is off-canvas. */
+    private cursorViewportPoint;
+    /** True while a synthetic-cursor repaint is queued, so rapid moves coalesce to one `requestAnimationFrame`. */
+    private cursorPaintScheduled;
+    /**
+     * True while the user is mid-drag on the canvas (a `mousedown` not yet released) — drives forwarding
+     * intermediate moves as a drag and emitting the closing `pointer-up`. Click-drag text selection relies on
+     * this so the drag relays as down → moves → up rather than a single discrete click.
+     */
+    private dragging;
+    /**
+     * True when the most recent `mousedown`→`mouseup` actually MOVED (a real drag), so the synthetic `click`
+     * the browser fires right after should be suppressed — the drag's down/move/up already conveyed the intent,
+     * and a trailing click would collapse a just-made text selection.
+     */
+    private suppressNextClick;
+    /** Viewport point of the active drag's mousedown, used to tell a real drag from a stationary click. */
+    private dragStartPoint;
+    /**
+     * True while the takeover canvas currently HOLDS keyboard focus. The host overlay reads this (via
+     * {@link IsCapturingInput}) to suppress its own global key shortcuts (e.g. T-to-type) so the user's
+     * keystrokes land in the remote browser, not the local composer — fixing the "greedy textbox" focus theft.
+     */
+    private surfaceFocused;
+    /** Bound handlers — stored so the exact same references can be removed on detach. */
+    private readonly onCanvasMouseMove;
+    private readonly onCanvasMouseDown;
+    private readonly onCanvasMouseUp;
+    private readonly onCanvasClick;
+    private readonly onCanvasKeyDown;
+    private readonly onCanvasMouseLeave;
+    private readonly onCanvasWheel;
+    private readonly onCanvasFocus;
+    private readonly onCanvasBlur;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Starts the interval poll OUTSIDE Angular's zone so it doesn't trigger CD on every tick. */
+    private startPolling;
+    /** Stops the interval poll (no further snapshot requests are issued). */
+    private stopPolling;
+    /**
+     * Fetches one snapshot and applies it to the view. Best-effort: the fetcher resolves to
+     * `null` on failure (the prior frame stays on screen) so a single failed poll never breaks
+     * the live view. Skips when a prior poll is still in flight, the fetcher isn't wired, or
+     * after destroy.
+     */
+    private pollOnce;
+    /** Applies a fetched snapshot to the view fields and triggers OnPush change detection. */
+    private applySnapshot;
+    /**
+     * Paints one PUSHED screencast frame (base64 JPEG) onto the canvas. Called by the channel plugin for
+     * each frame the server pushes while {@link Streaming}. Coalesces a burst of frames to one paint per
+     * animation frame (the newest wins) so a fast stream never floods the main thread, and reuses a single
+     * `Image` decode target to avoid per-frame allocation. No-op after destroy or when not in streaming mode.
+     *
+     * @param dataBase64 The frame image as raw base64 JPEG (no `data:` prefix).
+     */
+    RenderFrame(dataBase64: string): void;
+    /**
+     * Updates the URL shown above the live view. In streaming (canvas) mode the snapshot poll is stopped, so
+     * the channel pushes the current URL here after a navigation/action reports one — otherwise the bar would
+     * stay stuck on "No page loaded yet" even though the page is live. No-op for an unchanged / empty value.
+     *
+     * @param url The current page URL, or null/empty to leave the bar unchanged.
+     */
+    SetCurrentUrl(url: string | null | undefined): void;
+    /** Drains the most recent pending frame onto the canvas (drop-old coalescing target). */
+    private paintPendingFrame;
+    /** Draws the decoded frame image onto the canvas, sizing the canvas to the frame on the first paint. */
+    private drawFrameImage;
+    /**
+     * Attaches or detaches the canvas takeover listeners so they're bound exactly when takeover is live —
+     * {@link CanTakeOver} is true AND the canvas element exists. Idempotent: re-binds only when the target
+     * canvas changed, detaches when the conditions no longer hold. Safe to call from any state-flip path
+     * (the `Interactive`/`Streaming` setters, the first-frame paint, destroy).
+     */
+    private syncTakeoverListeners;
+    /** Binds the pointer/keyboard/wheel listeners to the canvas OUTSIDE the zone (mousemove/wheel are high-frequency). */
+    private attachTakeoverListeners;
+    /** Removes the listeners from the currently-bound canvas (no-op when none are bound) and clears the cursor. */
+    private detachTakeoverListeners;
+    /**
+     * Pointer-move → tracks the cursor for the synthetic-cursor overlay (every move, immediate, no
+     * round-trip) AND emits a throttled viewport-mapped move to the server. Runs outside the zone (no CD
+     * per move).
+     */
+    private handlePointerMove;
+    /** Mouse leaves the canvas → hide the synthetic cursor (nothing to relay). */
+    private handleMouseLeave;
+    /**
+     * Wheel/trackpad/Magic-Mouse scroll over the canvas → forwards a viewport-mapped scroll to the server.
+     * Calls `preventDefault` so the host page doesn't scroll while the user drives the live page. Throttled
+     * to {@link SCROLL_THROTTLE_MS}, coalescing the skipped deltas so no scroll distance is lost.
+     */
+    private handleWheel;
+    /**
+     * Mouse-down on the canvas → focuses the canvas (so subsequent keys are captured) and BEGINS a drag:
+     * emits a `pointer-down` and arms drag mode so the following moves relay as drag motion and the matching
+     * `pointer-up` closes it. This is what makes click-drag text selection work (rather than a discrete click).
+     */
+    private handlePointerDown;
+    /**
+     * Mouse-up on the canvas → closes a drag with a `pointer-up` at the release point, disarming drag mode.
+     * If the pointer actually moved between down and up, marks the following synthetic `click` to be suppressed
+     * (so the drag selection isn't immediately collapsed by a trailing click).
+     */
+    private handlePointerUp;
+    /**
+     * Click → emits a viewport-mapped click WITH any held modifiers (e.g. Shift-click text selection). The
+     * server browser receives the press/release of a drag via {@link handlePointerDown}/{@link handlePointerUp};
+     * a plain click (down+up with no motion) still fires this `click` event, so a simple click relays as one
+     * click action — but we skip emitting it when it terminates a real drag (where down/up already covered it).
+     */
+    private handlePointerClick;
+    /**
+     * Keydown → forwards printable keys, a curated set of control keys ({@link FORWARDED_CONTROL_KEYS}), AND
+     * any key combined with a Ctrl/Cmd/Alt modifier (so combos like Ctrl/Cmd+A select-all, Cmd+C/Cmd+V relay).
+     * Calls `preventDefault` + `stopPropagation` ONLY on forwarded keys, so (a) the host app keeps its own
+     * shortcuts on un-forwarded keys and (b) forwarded keys never bubble to the host overlay's global shortcuts
+     * (the T-to-type focus-steal). Lone modifier keys are never forwarded — they ride as `modifiers` on the
+     * next key/click.
+     */
+    private handleKeyDown;
+    /**
+     * Collects the modifier keys currently held during a DOM mouse/keyboard event into the relayed
+     * {@link RemoteBrowserModifier} list (empty when none are held).
+     *
+     * @param event The DOM event whose modifier flags to read.
+     * @returns The held modifiers, in a stable order.
+     */
+    private collectModifiers;
+    /** Re-enters the zone to emit one human input (so subscribers see it inside Angular). */
+    private emitInput;
+    /**
+     * Maps a DOM pointer event on the live canvas to VIEWPORT coordinates via {@link MapToViewportCoords}
+     * (the pure, unit-tested mapping). Returns `null` when no canvas is bound or mapping isn't possible yet.
+     *
+     * @param event The pointer event on the canvas.
+     * @returns The integer viewport coordinates, or `null` when mapping isn't possible yet.
+     */
+    private toViewportCoords;
+    /**
+     * Schedules a synthetic-cursor repaint on the next animation frame, coalescing a burst of moves to one
+     * paint (the newest position wins). Runs outside the zone — drawing the cursor never triggers Angular CD.
+     */
+    private scheduleCursorPaint;
+    /**
+     * Draws (or clears) the synthetic cursor on the overlay canvas at {@link cursorViewportPoint}. The overlay
+     * shares the frame canvas's internal resolution (sized here to match), so a point drawn at viewport coords
+     * aligns exactly with the page underneath. A small brand-tinted ring with a center dot reads as a pointer
+     * without obscuring what it's over. No-op after destroy or when the overlay isn't mounted.
+     */
+    private paintSyntheticCursor;
+    /** Clears the synthetic-cursor overlay (e.g. on detach). No-op when the overlay isn't mounted. */
+    private clearSyntheticCursor;
+    /**
+     * Resolves a CSS custom property (design token) to its computed color value off the host element, so the
+     * canvas-drawn cursor honors theming. Falls back to the supplied default when the token is unset or the
+     * host isn't measurable.
+     *
+     * @param token The CSS custom property name (e.g. `'--mj-brand-primary'`).
+     * @param fallback The color to use when the token resolves empty.
+     * @returns The resolved color string.
+     */
+    private resolveCssColor;
+    /** Maps a DOM `MouseEvent.button` (0/1/2) to the relayed button union, defaulting to `'left'`. */
+    private mapButton;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoteBrowserSurfaceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RemoteBrowserSurfaceComponent, "mj-realtime-remote-browser-surface", never, { "Fetch": { "alias": "Fetch"; "required": false; }; "Streaming": { "alias": "Streaming"; "required": false; }; "Interactive": { "alias": "Interactive"; "required": false; }; "AudioAvailable": { "alias": "AudioAvailable"; "required": false; }; "AudioMuted": { "alias": "AudioMuted"; "required": false; }; }, { "HumanInput": "HumanInput"; "AudioMutedChange": "AudioMutedChange"; }, never, never, true, never>;
+}
+//# sourceMappingURL=remote-browser-surface.component.d.ts.map

package/dist/lib/components/realtime/remote-browser/remote-browser-surface.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-browser-surface.component.d.ts","sourceRoot":"","sources":["../../../../../src/lib/components/realtime/remote-browser/remote-browser-surface.component.ts"],"names":[],"mappings":"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"}