@push.rocks/smartbrowser 4.1.0 → 4.3.0

package/dist_ts_web/classes.livebrowserrenderer.d.ts

@@ -0,0 +1,194 @@
+import type { ILiveBrowserCanvasRendererOptions } from './interfaces.livebrowsercanvas.js';
+import type { ILiveBrowserVideoRendererOptions, ILiveBrowserVideoRendererStatistics } from './interfaces.livebrowservideo.js';
+/**
+ * Renders transport-neutral live browser frames and maps DOM input back to the
+ * currently displayed SmartPuppeteer frame identity.
+ */
+export declare class LiveBrowserRenderer {
+    private readonly canvas;
+    private readonly videoReceiver?;
+    private readonly canvasContext?;
+    private readonly bitmapContext?;
+    private readonly client;
+    private readonly focusTarget;
+    private readonly resizeTarget?;
+    private readonly getDeviceScaleFactor;
+    private readonly operationTimeoutMs;
+    private readonly frameDecodeTimeoutMs;
+    private readonly onError?;
+    private readonly onFrameRendered?;
+    private readonly initialCanvasWidth;
+    private readonly initialCanvasHeight;
+    private lifecycleTail;
+    private runEpoch;
+    private running;
+    private suspended;
+    private stopping;
+    private interruptionRequested;
+    private runController?;
+    private operationControllers;
+    private acceptingFrames;
+    private state?;
+    private unsubscribe?;
+    private listenerController?;
+    private resizeObserver?;
+    private focusWasAdjusted;
+    private focusHadTabIndex;
+    private focusTabIndexValue;
+    private displayedFrame?;
+    private highestFrameSequence;
+    private queuedFrame?;
+    private frameProcessingPromise?;
+    private pendingDraw?;
+    private drawSchedule?;
+    private acknowledgementPromises;
+    private rawDecodeSettlementPromises;
+    private inputBlocked;
+    private inputCommands;
+    private inFlightInputCommands;
+    private inFlightWheelCommands;
+    private inputIdleResolvers;
+    private inputResetTail;
+    private inputResetPromise?;
+    private inputResetCount;
+    private pendingWheel?;
+    private wheelFlushSchedule?;
+    private wheelFrameElapsed;
+    private pressedKeys;
+    private pressedMouseButtons;
+    private capturedPointerIds;
+    private pendingViewport?;
+    private inFlightViewport?;
+    private viewportProcessing;
+    private viewportProcessingPromise?;
+    private resizeFence?;
+    private lastRequestedViewport?;
+    private resizeDebounceTimer?;
+    private pendingResizeSize?;
+    private readonly statistics;
+    constructor(optionsArg: ILiveBrowserCanvasRendererOptions | ILiveBrowserVideoRendererOptions);
+    get isRunning(): boolean;
+    get isSuspended(): boolean;
+    /**
+     * Cumulative frame and input counters for this renderer instance across runs.
+     */
+    getStatistics(): ILiveBrowserVideoRendererStatistics;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Aborts the current transport generation without replaying input recovery.
+     */
+    suspend(): Promise<void>;
+    /**
+     * Starts a new transport generation that requires new state and a new frame.
+     */
+    resume(): Promise<void>;
+    /**
+     * Sends arbitrary committed text, including text produced by an external IME.
+     */
+    insertText(textArg: string): Promise<void>;
+    /**
+     * Reads the configured stable resize target and requests the corresponding
+     * remote CSS viewport. Intrinsic canvas dimensions are never used here.
+     */
+    syncViewport(): void;
+    private enqueueLifecycle;
+    private startRun;
+    private interruptRun;
+    private finishRun;
+    private restoreCanvasAndFocus;
+    private installDomListeners;
+    private installResizeObserver;
+    private clearResizeDebounce;
+    private handleEvent;
+    private applyState;
+    private presentVideo;
+    private isStateAheadOfDisplayedFrame;
+    private queueFrame;
+    private ensureFrameProcessor;
+    private processFrameQueue;
+    private processFrame;
+    /**
+     * Keeps only the newest decoded bitmap and presents it on the next animation frame.
+     */
+    private setPendingDraw;
+    private discardPendingDraw;
+    private drawPendingFrame;
+    /**
+     * Presents one decoded bitmap. The canvas backing store is reallocated only
+     * when the frame dimensions differ from the current intrinsic dimensions.
+     */
+    private paintBitmap;
+    private canRenderFrame;
+    private acknowledgeFrame;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handleWheel;
+    /**
+     * Flushes accumulated wheel input at most once per animation frame and only
+     * while no wheel dispatch is in flight; the settling dispatch flushes the rest.
+     */
+    private tryFlushPendingWheel;
+    private scheduleWheelFlush;
+    /**
+     * Moves the accumulated wheel input into the command queue regardless of the
+     * frame gate so that later discrete commands stay behind it.
+     */
+    private flushPendingWheel;
+    private discardPendingWheel;
+    private handleKey;
+    private mapCoordinates;
+    private getMouseButton;
+    private getInputFrame;
+    private requireInputFrame;
+    private isDisplayedFrameCurrent;
+    private enqueueInputCommand;
+    /**
+     * Coalescable commands never exhaust capacity: they merge into a same-kind
+     * queue tail or evict the oldest queued coalescable command under pressure.
+     */
+    private enqueueCoalescableCommand;
+    private dropOldestCoalescableCommand;
+    /**
+     * Dispatches queued commands in order with a bounded number in flight. The
+     * remote session processes operations sequentially, so order is preserved.
+     */
+    private processInputCommands;
+    private dispatchInputCommand;
+    private handleInputDispatchFailure;
+    private waitForInputIdle;
+    private scheduleInputReset;
+    private releasePressedInput;
+    private tryInputRelease;
+    private reportInputReleaseError;
+    private queueViewport;
+    private normalizeGeneratedViewport;
+    private ensureViewportProcessor;
+    private processViewportQueue;
+    private updateInputAvailability;
+    private followNegotiatedViewport;
+    private makeFocusTargetFocusable;
+    private restoreFocusTarget;
+    private clearCanvas;
+    /**
+     * Runs work on the next animation frame, or after one nominal frame period
+     * when the document is not visible and animation frames would not fire.
+     */
+    private scheduleAnimationFrame;
+    private cancelScheduledFrame;
+    private callFrameRendered;
+    private reportError;
+    private requestSuspend;
+    private validateTimeout;
+    private runClientOperation;
+    private runAbortableOperation;
+    private decodeFrame;
+    private isRunActive;
+    private validateFrame;
+    private validateViewport;
+    private validateProtocolInteger;
+    private validateProtocolNumber;
+    private releasePointerCapture;
+    private releasePointerCaptures;
+}