devtools-tracing 1.2.0 → 1.2.2

package/dist/lib/front_end/core/sdk/HeapProfilerModel.d.ts

@@ -0,0 +1,75 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Platform from '../platform/platform.js';
+import type { DebuggerModel } from './DebuggerModel.js';
+import type { RemoteObject } from './RemoteObject.js';
+import { RuntimeModel } from './RuntimeModel.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class HeapProfilerModel extends SDKModel<EventTypes> {
+    #private;
+    constructor(target: Target);
+    debuggerModel(): DebuggerModel;
+    runtimeModel(): RuntimeModel;
+    enable(): Promise<void>;
+    startSampling(samplingRateInBytes?: number): Promise<boolean>;
+    stopSampling(): Promise<Protocol.HeapProfiler.SamplingHeapProfile | null>;
+    getSamplingProfile(): Promise<Protocol.HeapProfiler.SamplingHeapProfile | null>;
+    collectGarbage(): Promise<boolean>;
+    snapshotObjectIdForObjectId(objectId: Protocol.Runtime.RemoteObjectId): Promise<string | null>;
+    objectForSnapshotObjectId(snapshotObjectId: Protocol.HeapProfiler.HeapSnapshotObjectId, objectGroupName: string): Promise<RemoteObject | null>;
+    addInspectedHeapObject(snapshotObjectId: Protocol.HeapProfiler.HeapSnapshotObjectId): Promise<boolean>;
+    takeHeapSnapshot(heapSnapshotOptions: Protocol.HeapProfiler.TakeHeapSnapshotRequest): Promise<void>;
+    startTrackingHeapObjects(recordAllocationStacks: boolean): Promise<boolean>;
+    stopTrackingHeapObjects(reportProgress: boolean): Promise<boolean>;
+    heapStatsUpdate(samples: number[]): void;
+    lastSeenObjectId(lastSeenObjectId: number, timestamp: number): void;
+    addHeapSnapshotChunk(chunk: string): void;
+    reportHeapSnapshotProgress(done: number, total: number, finished?: boolean): void;
+    resetProfiles(): void;
+}
+export declare const enum Events {
+    HEAP_STATS_UPDATED = "HeapStatsUpdate",
+    LAST_SEEN_OBJECT_ID = "LastSeenObjectId",
+    ADD_HEAP_SNAPSHOT_CHUNK = "AddHeapSnapshotChunk",
+    REPORT_HEAP_SNAPSHOT_PROGRESS = "ReportHeapSnapshotProgress",
+    RESET_PROFILES = "ResetProfiles"
+}
+/**
+ * An array of triplets. Each triplet describes a fragment. The first number is the fragment
+ * index, the second number is a total count of objects for the fragment, the third number is
+ * a total size of the objects for the fragment.
+ */
+export type HeapStatsUpdateSamples = number[];
+export interface LastSeenObjectId {
+    lastSeenObjectId: number;
+    timestamp: number;
+}
+export interface HeapSnapshotProgress {
+    done: number;
+    total: number;
+    finished?: boolean;
+}
+export interface EventTypes {
+    [Events.HEAP_STATS_UPDATED]: HeapStatsUpdateSamples;
+    [Events.LAST_SEEN_OBJECT_ID]: LastSeenObjectId;
+    [Events.ADD_HEAP_SNAPSHOT_CHUNK]: string;
+    [Events.REPORT_HEAP_SNAPSHOT_PROGRESS]: HeapSnapshotProgress;
+    [Events.RESET_PROFILES]: HeapProfilerModel;
+}
+export interface NativeProfilerCallFrame {
+    functionName: string;
+    url: Platform.DevToolsPath.UrlString;
+    scriptId?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+}
+export interface CommonHeapProfileNode {
+    callFrame: NativeProfilerCallFrame;
+    selfSize: number;
+    id?: number;
+    children: CommonHeapProfileNode[];
+}
+export interface CommonHeapProfile {
+    head: CommonHeapProfileNode;
+    modules: Protocol.Memory.Module[];
+}

package/dist/lib/front_end/core/sdk/HttpReasonPhraseStrings.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reason phrase sources
+ * See https://www.rfc-editor.org/rfc/rfc9110.html#name-status-codes
+ **/
+export declare function getStatusText(statusCode: number): string;

package/dist/lib/front_end/core/sdk/IOModel.d.ts

@@ -0,0 +1,10 @@
+import type * as Protocol from '../../generated/protocol.js';
+import { RemoteObject } from './RemoteObject.js';
+import { SDKModel } from './SDKModel.js';
+export declare class IOModel extends SDKModel<void> {
+    read(handle: Protocol.IO.StreamHandle, size?: number, offset?: number): Promise<string | Uint8Array | null>;
+    close(handle: Protocol.IO.StreamHandle): Promise<void>;
+    resolveBlob(objectOrObjectId: Protocol.Runtime.RemoteObjectId | RemoteObject): Promise<string>;
+    readToString(handle: Protocol.IO.StreamHandle): Promise<string>;
+    readToBuffer(handle: Protocol.IO.StreamHandle): Promise<Uint8Array<ArrayBuffer>>;
+}

package/dist/lib/front_end/core/sdk/IsolateManager.d.ts

@@ -0,0 +1,52 @@
+import * as Common from '../common/common.js';
+import type { HeapProfilerModel } from './HeapProfilerModel.js';
+import { RuntimeModel } from './RuntimeModel.js';
+import { type SDKModelObserver } from './TargetManager.js';
+export declare class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements SDKModelObserver<RuntimeModel> {
+    #private;
+    constructor();
+    static instance({ forceNew }?: {
+        forceNew: boolean;
+    }): IsolateManager;
+    observeIsolates(observer: Observer): void;
+    modelAdded(model: RuntimeModel): void;
+    modelRemoved(model: RuntimeModel): void;
+    isolateByModel(model: RuntimeModel): Isolate | null;
+    isolates(): Iterable<Isolate>;
+    private poll;
+}
+export interface Observer {
+    isolateAdded(isolate: Isolate): void;
+    isolateRemoved(isolate: Isolate): void;
+    isolateChanged(isolate: Isolate): void;
+}
+export declare const enum Events {
+    MEMORY_CHANGED = "MemoryChanged"
+}
+export interface EventTypes {
+    [Events.MEMORY_CHANGED]: Isolate;
+}
+export declare const MemoryTrendWindowMs = 120000;
+export declare class Isolate {
+    #private;
+    constructor(id: string);
+    id(): string;
+    models(): Set<RuntimeModel>;
+    runtimeModel(): RuntimeModel | null;
+    heapProfilerModel(): HeapProfilerModel | null;
+    update(): Promise<void>;
+    samplesCount(): number;
+    usedHeapSize(): number;
+    /**
+     * bytes per millisecond
+     */
+    usedHeapSizeGrowRate(): number;
+}
+export declare class MemoryTrend {
+    #private;
+    constructor(maxCount: number);
+    reset(): void;
+    count(): number;
+    add(heapSize: number, timestamp?: number): void;
+    fitSlope(): number;
+}

package/dist/lib/front_end/core/sdk/IssuesModel.d.ts

@@ -0,0 +1,28 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+/**
+ * The `IssuesModel` is a thin dispatch that does not store issues, but only creates the representation
+ * class (usually derived from `Issue`) and passes the instances on via a dispatched event.
+ * We chose this approach here because the lifetime of the Model is tied to the target, but DevTools
+ * wants to preserve issues for targets (e.g. iframes) that are already gone as well.
+ */
+export declare class IssuesModel extends SDKModel<EventTypes> implements ProtocolProxyApi.AuditsDispatcher {
+    #private;
+    constructor(target: Target);
+    private ensureEnabled;
+    issueAdded(issueAddedEvent: Protocol.Audits.IssueAddedEvent): void;
+    dispose(): void;
+    getTargetIfNotDisposed(): Target | null;
+}
+export declare const enum Events {
+    ISSUE_ADDED = "IssueAdded"
+}
+export interface IssueAddedEvent {
+    issuesModel: IssuesModel;
+    inspectorIssue: Protocol.Audits.InspectorIssue;
+}
+export interface EventTypes {
+    [Events.ISSUE_ADDED]: IssueAddedEvent;
+}

package/dist/lib/front_end/core/sdk/LayerTreeBase.d.ts

@@ -0,0 +1,70 @@
+import type * as Protocol from '../../generated/protocol.js';
+import { type DOMNode } from './DOMModel.js';
+import type { SnapshotWithRect } from './PaintProfiler.js';
+import type { Target } from './Target.js';
+export interface Layer {
+    id(): string;
+    parentId(): string | null;
+    parent(): Layer | null;
+    isRoot(): boolean;
+    children(): Layer[];
+    addChild(child: Layer): void;
+    node(): DOMNode | null;
+    nodeForSelfOrAncestor(): DOMNode | null;
+    offsetX(): number;
+    offsetY(): number;
+    width(): number;
+    height(): number;
+    transform(): number[] | null;
+    quad(): number[];
+    anchorPoint(): number[];
+    invisible(): boolean;
+    paintCount(): number;
+    lastPaintRect(): Protocol.DOM.Rect | null;
+    scrollRects(): Protocol.LayerTree.ScrollRect[];
+    stickyPositionConstraint(): StickyPositionConstraint | null;
+    gpuMemoryUsage(): number;
+    requestCompositingReasons(): Promise<string[]>;
+    requestCompositingReasonIds(): Promise<string[]>;
+    drawsContent(): boolean;
+    snapshots(): Array<Promise<SnapshotWithRect | null>>;
+}
+export declare namespace Layer {
+    const enum ScrollRectType {
+        NON_FAST_SCROLLABLE = "NonFastScrollable",
+        TOUCH_EVENT_HANDLER = "TouchEventHandler",
+        WHEEL_EVENT_HANDLER = "WheelEventHandler",
+        REPAINTS_ON_SCROLL = "RepaintsOnScroll",
+        MAIN_THREAD_SCROLL_REASON = "MainThreadScrollingReason"
+    }
+}
+export declare class StickyPositionConstraint {
+    #private;
+    constructor(layerTree: LayerTreeBase | null, constraint: Protocol.LayerTree.StickyPositionConstraint);
+    stickyBoxRect(): Protocol.DOM.Rect;
+    containingBlockRect(): Protocol.DOM.Rect;
+    nearestLayerShiftingStickyBox(): Layer | null;
+    nearestLayerShiftingContainingBlock(): Layer | null;
+}
+export declare class LayerTreeBase {
+    #private;
+    layersById: Map<string | number, Layer>;
+    constructor(target: Target | null);
+    target(): Target | null;
+    root(): Layer | null;
+    setRoot(root: Layer | null): void;
+    contentRoot(): Layer | null;
+    setContentRoot(contentRoot: Layer | null): void;
+    forEachLayer<T>(callback: (arg0: Layer) => T, root?: Layer | null): T | boolean;
+    layerById(id: string): Layer | null;
+    resolveBackendNodeIds(requestedNodeIds: Set<Protocol.DOM.BackendNodeId>): Promise<void>;
+    backendNodeIdToNode(): Map<Protocol.DOM.BackendNodeId, DOMNode | null>;
+    setViewportSize(viewportSize: {
+        width: number;
+        height: number;
+    }): void;
+    viewportSize(): {
+        width: number;
+        height: number;
+    } | undefined;
+}

package/dist/lib/front_end/core/sdk/LogModel.d.ts

@@ -0,0 +1,20 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import * as Protocol from '../../generated/protocol.js';
+import { SDKModel } from './SDKModel.js';
+import { type Target } from './Target.js';
+export declare class LogModel extends SDKModel<EventTypes> implements ProtocolProxyApi.LogDispatcher {
+    #private;
+    constructor(target: Target);
+    entryAdded({ entry }: Protocol.Log.EntryAddedEvent): void;
+    requestClear(): void;
+}
+export declare const enum Events {
+    ENTRY_ADDED = "EntryAdded"
+}
+export interface EntryAddedEvent {
+    logModel: LogModel;
+    entry: Protocol.Log.LogEntry;
+}
+export interface EventTypes {
+    [Events.ENTRY_ADDED]: EntryAddedEvent;
+}