@memlab/core 1.1.19 → 1.1.21

package/dist/lib/Utils.js

@@ -44,7 +44,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregateDominatorMetrics = exports.getRetainedSize = exports.runShell = exports.resolveSnapshotFilePath = void 0;
+exports.runShell = exports.resolveSnapshotFilePath = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = __importDefault(require("child_process"));
@@ -53,7 +53,6 @@ const Config_1 = __importStar(require("./Config"));
 const Console_1 = __importDefault(require("./Console"));
 const Constant_1 = __importDefault(require("./Constant"));
 const HeapParser_1 = __importDefault(require("./HeapParser"));
-const BrowserInfo_1 = __importDefault(require("./BrowserInfo"));
 const memCache = Object.create(null);
 const FileManager_1 = __importDefault(require("./FileManager"));
 const __1 = require("..");
@@ -133,6 +132,21 @@ function isFiberNode(node) {
 function isDetachedFiberNode(node) {
     return isFiberNode(node) && isDetached(node);
 }
+// return true if this node is InternalNode (native)
+function isDOMInternalNode(node) {
+    if (node == null) {
+        return false;
+    }
+    return (node.type === 'native' &&
+        (node.name === 'InternalNode' || node.name === 'Detached InternalNode'));
+}
+// return true the the nodee is a global handles node
+function isGlobalHandlesNode(node) {
+    if (node == null) {
+        return false;
+    }
+    return node.name === '(Global handles)' && node.type === 'synthetic';
+}
 // this function returns a more general sense of DOM nodes. Specifically,
 // any detached DOM nodes (e.g., HTMLXXElement, IntersectionObserver etc.)
 // that are not internal nodes.
@@ -211,18 +225,51 @@ function isPendingActivityNode(node) {
     if (!node || !node.name) {
         return false;
     }
-    return node.type === 'synthetic' && node.name === 'Pending activities';
+    if (node.type !== 'synthetic' && node.type !== 'native') {
+        return false;
+    }
+    return node.name === 'Pending activities';
 }
+const htmlElementRegex = /^HTML.*Element$/;
+const svgElementRegex = /^SVG.*Element$/;
+const htmlCollectionRegex = /^HTML.*Collection$/;
+const cssElementRegex = /^CSS/;
+const styleSheetRegex = /StyleSheet/;
+// special DOM element names that are not
+// included in the previous regex definitions
+const domElementSpecialNames = new Set([
+    'DOMTokenList',
+    'HTMLDocument',
+    'InternalNode',
+    'Text',
+    'XMLDocument',
+]);
 // check the node against a curated list of known HTML Elements
 // the list may be incomplete
 function isDOMNodeIncomplete(node) {
+    if (node.type !== 'native') {
+        return false;
+    }
     let name = node.name;
-    const pattern = /^HTML.*Element$/;
     const detachedPrefix = 'Detached ';
     if (name.startsWith(detachedPrefix)) {
         name = name.substring(detachedPrefix.length);
     }
-    return pattern.test(name);
+    return (htmlElementRegex.test(name) ||
+        svgElementRegex.test(name) ||
+        cssElementRegex.test(name) ||
+        styleSheetRegex.test(name) ||
+        htmlCollectionRegex.test(name) ||
+        domElementSpecialNames.has(name));
+}
+function isXMLDocumentNode(node) {
+    return node.type === 'native' && node.name === 'XMLDocument';
+}
+function isHTMLDocumentNode(node) {
+    return node.type === 'native' && node.name === 'HTMLDocument';
+}
+function isDOMTextNode(node) {
+    return node.type === 'native' && node.name === 'Text';
 }
 function isRootNode(node, opt = {}) {
     if (!node) {
@@ -471,7 +518,9 @@ function applyToNodes(idSet, snapshot, cb, options = {}) {
     for (const id of ids) {
         const node = snapshot.getNodeById(id);
         if (!node) {
-            Console_1.default.warning(`node @${id} is not found`);
+            if (Config_1.default.verbose) {
+                Console_1.default.warning(`node @${id} is not found`);
+            }
             return;
         }
         cb(node, snapshot);
@@ -831,27 +880,6 @@ function hasOnlyWeakReferrers(node) {
     (edge) => edge.type !== 'weak' && edge.type !== 'shortcut');
     return referrer == null;
 }
-function getRunMetaFilePath() {
-    return Config_1.default.useExternalSnapshot
-        ? Config_1.default.externalRunMetaFile
-        : Config_1.default.runMetaFile;
-}
-function loadRunMetaInfo(metaFile = undefined) {
-    const file = metaFile || getRunMetaFilePath();
-    try {
-        const content = fs_1.default.readFileSync(file, 'UTF-8');
-        return JSON.parse(content);
-    }
-    catch (_) {
-        throw haltOrThrow('Run info missing. Please make sure `memlab run` is complete.');
-    }
-}
-function loadTargetInfoFromRunMeta() {
-    const meta = loadRunMetaInfo();
-    Config_1.default.targetApp = meta.app;
-    Config_1.default.targetTab = meta.interaction;
-    BrowserInfo_1.default.load(meta.browserInfo);
-}
 function getSnapshotSequenceFilePath() {
     if (!Config_1.default.useExternalSnapshot) {
         // load the snapshot sequence meta file from the default location
@@ -870,7 +898,9 @@ function getSnapshotSequenceFilePath() {
 // this should be called only after exploration
 function loadTabsOrder(metaFile = undefined) {
     try {
-        const file = metaFile || getSnapshotSequenceFilePath();
+        const file = metaFile != null && fs_1.default.existsSync(metaFile)
+            ? metaFile
+            : getSnapshotSequenceFilePath();
         const content = fs_1.default.readFileSync(file, 'UTF-8');
         return JSON.parse(content);
     }
@@ -878,31 +908,6 @@ function loadTabsOrder(metaFile = undefined) {
         throw haltOrThrow('snapshot meta data invalid or missing');
     }
 }
-// if true the leak trace is will be reported
-function isInterestingPath(p) {
-    // do not filter paths when analyzing Hermes snapshots
-    if (Config_1.default.jsEngine === 'hermes') {
-        return true;
-    }
-    // if the path has pattern: Window -> [InternalNode]+ -> DetachedElement
-    if (Config_1.default.hideBrowserLeak && internalNodeRetainsDetachedElement(p)) {
-        return false;
-    }
-    // if the path has pattern: ShadowRoot -> DetachedElement
-    if (Config_1.default.hideBrowserLeak && shadowRootRetainsDetachedElement(p)) {
-        return false;
-    }
-    // if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
-    if (Config_1.default.hideBrowserLeak && styleEngineRetainsDetachedElement(p)) {
-        return false;
-    }
-    // if the path has pattern: Pending activitiies -> DetachedElement
-    if (Config_1.default.hideBrowserLeak &&
-        pendingActivitiesRetainsDetachedElementChain(p)) {
-        return false;
-    }
-    return true;
-}
 // return true if the heap node represents JS object or closure
 function isObjectNode(node) {
     if (isPlainJSObjectNode(node)) {
@@ -920,89 +925,6 @@ function isPlainJSObjectNode(node) {
     }
     return node.name === 'Object';
 }
-// check if the path has pattern:
-// Window -> [InternalNode | Text]+ -> DetachedElement
-function internalNodeRetainsDetachedElement(path) {
-    var _a, _b;
-    if (!path) {
-        return false;
-    }
-    let p = path;
-    // GC root is not Window
-    if (!p.node || !p.node.name.startsWith('Window')) {
-        return false;
-    }
-    p = p.next;
-    // Window is not poining to InternalNode
-    if (!p || !p.node || p.node.name !== 'InternalNode') {
-        return false;
-    }
-    // skip the rest InternalNode
-    while (((_a = p.node) === null || _a === void 0 ? void 0 : _a.name) === 'InternalNode' || ((_b = p.node) === null || _b === void 0 ? void 0 : _b.name) === 'Text') {
-        p = p.next;
-        if (!p) {
-            return false;
-        }
-    }
-    // check if the node is a detached element
-    return p && isDetachedDOMNode(p.node);
-}
-// check if the path has pattern: ShadowRoot -> DetachedElement
-function shadowRootRetainsDetachedElement(path) {
-    let p = path;
-    // find the ShadowRoot
-    while (p && p.node && p.node.name !== 'ShadowRoot') {
-        p = p.next;
-        if (!p) {
-            return false;
-        }
-    }
-    p = p.next;
-    // check if the node is a detached element
-    return !!p && isDetachedDOMNode(p.node);
-}
-// check if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
-function styleEngineRetainsDetachedElement(path) {
-    let p = path;
-    // find the StyleEngine
-    while (p && p.node && p.node.name !== 'StyleEngine') {
-        p = p.next;
-        if (!p) {
-            return false;
-        }
-    }
-    p = p.next;
-    // StyleEngine is not poining to InternalNode
-    if (!p || !p.node || p.node.name !== 'InternalNode') {
-        return false;
-    }
-    p = p.next;
-    // check if the InternalNode is pointing to a detached element
-    return !!p && isDetachedDOMNode(p.node);
-}
-function pendingActivitiesRetainsDetachedElementChain(path) {
-    let p = path;
-    // find the Pending activities
-    while (p && p.node && !isPendingActivityNode(p.node)) {
-        p = p.next;
-        if (!p) {
-            return false;
-        }
-    }
-    p = p.next;
-    if (!p || !p.node) {
-        return false;
-    }
-    // all the following reference chain is detached DOM elements
-    // pointing to other detached DOM elements
-    while (p && p.node) {
-        if (!isDetachedDOMNode(p.node)) {
-            return false;
-        }
-        p = p.next;
-    }
-    return true;
-}
 function pathHasDetachedHTMLNode(path) {
     if (!path) {
         return false;
@@ -1272,7 +1194,7 @@ function checkSnapshots(options = {}) {
         snapshotDir = Config_1.default.externalSnapshotDir || '<missing>';
     }
     else {
-        snapshotDir = FileManager_1.default.getCurDataDir({});
+        snapshotDir = FileManager_1.default.getCurDataDir({ workDir: Config_1.default.workDir });
     }
     if (options.snapshotDir) {
         const snapshots = getSnapshotFilesInDir(snapshotDir);
@@ -1347,6 +1269,9 @@ function getSingleSnapshotFileForAnalysis() {
     return resolveSnapshotFilePath(path);
 }
 function getSnapshotFilePath(tab, options = {}) {
+    if (tab.snapshotFile) {
+        return path_1.default.join(FileManager_1.default.getCurDataDir(options), tab.snapshotFile);
+    }
     const fileName = `s${tab.idx}.heapsnapshot`;
     if (options.workDir) {
         return path_1.default.join(FileManager_1.default.getCurDataDir(options), fileName);
@@ -1779,6 +1704,9 @@ function runShell(command, options = {}) {
                 Console_1.default.lowLevel((_c = ex.stack) !== null && _c !== void 0 ? _c : '');
             }
         }
+        if (options.throwError) {
+            throw ex;
+        }
         if (options.ignoreError === true) {
             return '';
         }
@@ -1790,7 +1718,6 @@ exports.runShell = runShell;
 function getRetainedSize(node) {
     return node.retainedSize;
 }
-exports.getRetainedSize = getRetainedSize;
 function aggregateDominatorMetrics(ids, snapshot, checkNodeCb, nodeMetricsCb) {
     let ret = 0;
     const dominators = __1.utils.getConditionalDominatorIds(ids, snapshot, checkNodeCb);
@@ -1799,15 +1726,51 @@ function aggregateDominatorMetrics(ids, snapshot, checkNodeCb, nodeMetricsCb) {
     });
     return ret;
 }
-exports.aggregateDominatorMetrics = aggregateDominatorMetrics;
+function getLeakTracePathLength(path) {
+    let len = 0;
+    let p = path;
+    while (p) {
+        p = p.next;
+        ++len;
+    }
+    return len;
+}
+function getNumberAtPercentile(arr, percentile) {
+    arr.sort(function (a, b) {
+        return a - b;
+    });
+    const index = (percentile / 100) * arr.length;
+    const indexInt = Math.floor(index);
+    if (indexInt === index) {
+        return arr[Math.floor(index)];
+    }
+    if (indexInt + 1 < arr.length) {
+        return (arr[indexInt] + arr[indexInt + 1]) / 2;
+    }
+    return arr[indexInt];
+}
+function mapToObject(map) {
+    const ret = Object.create(null);
+    map.forEach((v, k) => {
+        ret[k] = v;
+    });
+    return ret;
+}
+function objectToMap(object) {
+    const ret = new Map();
+    for (const k of Object.keys(object)) {
+        ret.set(k, object[k]);
+    }
+    return ret;
+}
 exports.default = {
     aggregateDominatorMetrics,
     applyToNodes,
     callAsync,
     camelCaseToReadableString,
+    checkIsChildOfParent,
     checkSnapshots,
     checkUninstalledLibrary,
-    checkIsChildOfParent,
     closePuppeteer,
     dumpSnapshot,
     equalOrMatch,
@@ -1816,29 +1779,31 @@ exports.default = {
     extractHTMLElementNodeInfo,
     filterNodesInPlace,
     getAllDominators,
+    getBooleanNodeValue,
     getClosureSourceUrl,
     getConditionalDominatorIds,
-    getError,
     getEdgeByNameAndType,
+    getError,
     getLastNodeId,
+    getLeakTracePathLength,
     getLeakedNode,
     getNodesIdSet,
+    getNumberAtPercentile,
     getNumberNodeValue,
     getReadableBytes,
     getReadablePercent,
     getReadableTime,
     getRetainedSize,
-    getRunMetaFilePath,
     getScenarioName,
     getSingleSnapshotFileForAnalysis,
     getSnapshotDirForAnalysis,
-    getSnapshotFilesInDir,
+    getSnapshotFilePath,
+    getSnapshotFilePathWithTabType,
     getSnapshotFilesFromTabsOrder,
+    getSnapshotFilesInDir,
     getSnapshotFromFile,
     getSnapshotNodeIdsFromFile,
     getSnapshotSequenceFilePath,
-    getSnapshotFilePath,
-    getSnapshotFilePathWithTabType,
     getStringNodeValue,
     getToNodeByEdge,
     getUniqueID,
@@ -1849,18 +1814,21 @@ exports.default = {
     hasReactEdges,
     isAlternateNode,
     isBlinkRootNode,
+    isDOMInternalNode,
+    isDOMNodeIncomplete,
+    isDOMTextNode,
     isDebuggableNode,
-    isDetachedFiberNode,
     isDetachedDOMNode,
+    isDetachedFiberNode,
     isDirectPropEdge,
     isDocumentDOMTreesRoot,
-    isDOMNodeIncomplete,
     isEssentialEdge,
     isFiberNode,
     isFiberNodeDeletionsEdge,
+    isGlobalHandlesNode,
+    isHTMLDocumentNode,
     isHermesInternalObject,
     isHostRoot,
-    isInterestingPath,
     isMeaningfulEdge,
     isMeaningfulNode,
     isNodeDominatedByDeletionsArray,
@@ -1879,17 +1847,18 @@ exports.default = {
     isWeakMapEdge,
     isWeakMapEdgeToKey,
     isWeakMapEdgeToValue,
+    isXMLDocumentNode,
     iterateChildFiberNodes,
     iterateDescendantFiberNodes,
-    loadRunMetaInfo,
     loadLeakFilter,
     loadScenario,
     loadTabsOrder,
-    loadTargetInfoFromRunMeta,
+    mapToObject,
     markAllDetachedFiberNode,
     markAlternateFiberNode,
     memCache,
     normalizeBaseUrl,
+    objectToMap,
     pathHasDetachedHTMLNode,
     pathHasEdgeWithIndex,
     repeat,
@@ -1902,5 +1871,4 @@ exports.default = {
     shuffleArray,
     throwError,
     upperCaseFirstCharacter,
-    getBooleanNodeValue,
 };

package/dist/lib/charts/MemoryBarChart.d.ts

@@ -10,6 +10,7 @@
 import type { PlotMemoryOptions } from '../Types';
 declare class MemoryBarChart {
     plotMemoryBarChart(options?: PlotMemoryOptions): void;
+    private isPlotDataValid;
     private loadPlotDataFromTabsOrder;
     private loadPlotDataFromWorkDir;
     private loadPlotData;

package/dist/lib/charts/MemoryBarChart.js

@@ -30,6 +30,12 @@ class MemoryBarChart {
             Console_1.default.warning(`plot data not load correctly: ${Utils_1.default.getError(ex).message}`);
             return;
         }
+        if (!this.isPlotDataValid(plotData)) {
+            if (Config_1.default.verbose) {
+                Console_1.default.warning('no memory usage data to plot');
+            }
+            return;
+        }
         // normalize plot data
         const minY = 1;
         const maxY = plotData.reduce((m, v) => Math.max(m, v[1]), 0) * 1.15;
@@ -51,6 +57,21 @@ class MemoryBarChart {
         }));
         Console_1.default.topLevel('');
     }
+    isPlotDataValid(plotData) {
+        if (plotData.length === 0) {
+            return false;
+        }
+        let isEntryValueAllZero = true;
+        for (const entry of plotData) {
+            if (entry.length !== 2) {
+                return false;
+            }
+            if (entry[1] !== 0) {
+                isEntryValueAllZero = false;
+            }
+        }
+        return !isEntryValueAllZero;
+    }
     loadPlotDataFromTabsOrder(tabsOrder) {
         for (const tab of tabsOrder) {
             if (!(tab.JSHeapUsedSize > 0)) {
@@ -76,12 +97,12 @@ class MemoryBarChart {
     }
     loadPlotData(options = {}) {
         // plot data for a single run
-        if (!options.controlWorkDir && !options.treatmentWorkDir) {
+        if (!options.controlWorkDirs && !options.treatmentWorkDir) {
             return this.loadPlotDataFromWorkDir(options);
         }
         // plot data for control and test run
         const controlPlotData = this.loadPlotDataFromWorkDir({
-            workDir: options.controlWorkDir,
+            workDir: options.controlWorkDirs && options.controlWorkDirs[0],
         });
         const testPlotData = this.loadPlotDataFromWorkDir({
             workDir: options.treatmentWorkDir,

package/dist/lib/heap-data/HeapEdge.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapEdge } from '../Types';
+import type { AnyRecord, AnyValue, IHeapEdge } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapNode from './HeapNode';
 export default class HeapEdge implements IHeapEdge {
@@ -23,5 +23,7 @@ export default class HeapEdge implements IHeapEdge {
     get to_node(): number;
     get toNode(): HeapNode;
     get fromNode(): HeapNode;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapEdge.d.ts.map

package/dist/lib/heap-data/HeapEdge.js

@@ -71,5 +71,18 @@ class HeapEdge {
         const srcNodeIdx = edgeIndex2SrcNodeIndex[this.idx];
         return new HeapNode_1.default(heapSnapshot, srcNodeIdx);
     }
+    getJSONifyableObject() {
+        return {
+            name_or_index: this.name_or_index,
+            type: this.type,
+            edgeIndex: this.edgeIndex,
+            toNode: this.toNode.getJSONifyableObject(),
+            fromNode: this.fromNode.getJSONifyableObject(),
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapEdge;

package/dist/lib/heap-data/HeapLocation.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapLocation, IHeapNode, Nullable } from '../Types';
+import type { AnyRecord, AnyValue, IHeapLocation, IHeapNode, Nullable } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 export default class HeapLocation implements IHeapLocation {
     private heapSnapshot;
@@ -19,5 +19,7 @@ export default class HeapLocation implements IHeapLocation {
     get script_id(): number;
     get line(): number;
     get column(): number;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapLocation.d.ts.map

package/dist/lib/heap-data/HeapLocation.js

@@ -43,5 +43,19 @@ class HeapLocation {
         const locationFieldsCount = heapSnapshot._locationFieldsCount;
         return locations[this.idx * locationFieldsCount + heapSnapshot._locationColumnOffset];
     }
+    getJSONifyableObject() {
+        const node = this.node;
+        const jsonNode = node == null ? null : node.getJSONifyableObject();
+        return {
+            node: jsonNode,
+            script_id: this.script_id,
+            line: this.line,
+            column: this.column,
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapLocation;

package/dist/lib/heap-data/HeapNode.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapNode, IHeapEdge, Nullable, EdgeIterationCallback, Predicator, IHeapStringNode } from '../Types';
+import type { IHeapNode, IHeapEdge, Nullable, EdgeIterationCallback, Predicator, IHeapStringNode, AnyRecord, AnyValue } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapEdge from './HeapEdge';
 import HeapLocation from './HeapLocation';
@@ -33,8 +33,11 @@ export default class HeapNode implements IHeapNode {
     forEachReference(callback: EdgeIterationCallback): void;
     findAnyReference(predicate: Predicator<IHeapEdge>): Nullable<IHeapEdge>;
     findAnyReferrer(predicate: Predicator<IHeapEdge>): Nullable<IHeapEdge>;
+    findAnyReferrerNode(predicate: Predicator<IHeapNode>): Nullable<IHeapNode>;
     findReferrers(predicate: Predicator<IHeapEdge>): IHeapEdge[];
+    findReferrerNodes(predicate: Predicator<IHeapNode>): IHeapNode[];
     get referrers(): HeapEdge[];
+    get numOfReferrers(): number;
     forEachReferrer(callback: EdgeIterationCallback): void;
     get hasPathEdge(): boolean;
     get pathEdge(): Nullable<HeapEdge>;
@@ -53,5 +56,7 @@ export default class HeapNode implements IHeapNode {
     getReferrerNodes(edgeName: string | number, edgeType?: string): IHeapNode[];
     get isString(): boolean;
     toStringNode(): Nullable<IHeapStringNode>;
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
 }
 //# sourceMappingURL=HeapNode.d.ts.map

package/dist/lib/heap-data/HeapNode.js

@@ -151,6 +151,17 @@ class HeapNode {
         });
         return found;
     }
+    findAnyReferrerNode(predicate) {
+        let found = null;
+        this.forEachReferrer((edge) => {
+            const node = edge.fromNode;
+            if (predicate(node)) {
+                found = node;
+                return { stop: true };
+            }
+        });
+        return found;
+    }
     findReferrers(predicate) {
         const ret = [];
         this.forEachReferrer((edge) => {
@@ -161,6 +172,17 @@ class HeapNode {
         });
         return ret;
     }
+    findReferrerNodes(predicate) {
+        const ret = [];
+        this.forEachReferrer((edge) => {
+            const node = edge.fromNode;
+            if (predicate(node)) {
+                ret.push(node);
+            }
+            return null;
+        });
+        return ret;
+    }
     get referrers() {
         const heapSnapshot = this.heapSnapshot;
         const retainingEdgeIndex2EdgeIndex = heapSnapshot._retainingEdgeIndex2EdgeIndex;
@@ -174,6 +196,13 @@ class HeapNode {
         }
         return ret;
     }
+    get numOfReferrers() {
+        const heapSnapshot = this.heapSnapshot;
+        const firstRetainerIndex = heapSnapshot._firstRetainerIndex;
+        const beginIdx = firstRetainerIndex[this.idx];
+        const endIdx = firstRetainerIndex[this.idx + 1];
+        return endIdx - beginIdx;
+    }
     forEachReferrer(callback) {
         const heapSnapshot = this.heapSnapshot;
         const retainingEdgeIndex2EdgeIndex = heapSnapshot._retainingEdgeIndex2EdgeIndex;
@@ -342,6 +371,23 @@ class HeapNode {
             ? new HeapStringNode_1.default(this.heapSnapshot, this.idx)
             : null;
     }
+    getJSONifyableObject() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            self_size: this.self_size,
+            trace_node_id: this.trace_node_id,
+            nodeIndex: this.nodeIndex,
+            outGoingEdgeCount: this.edge_count,
+            incomingEdgeCount: this.numOfReferrers,
+            contructorName: this.constructor.name,
+        };
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
 }
 exports.default = HeapNode;
 // HeapStringNode has to be imported after exporting HeapNode

package/dist/lib/heap-data/HeapSnapshot.d.ts

@@ -8,7 +8,7 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, HeapEdgeTypes, HeapSnapshotMeta, RawHeapSnapshot, NumericDictionary, Nullable } from '../Types';
+import type { AnyRecord, AnyValue, IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, HeapEdgeTypes, HeapSnapshotMeta, RawHeapSnapshot, NumericDictionary, Nullable } from '../Types';
 import HeapNode from './HeapNode';
 export default class HeapSnapshot implements IHeapSnapshot {
     snapshot: RawHeapSnapshot;
@@ -67,6 +67,8 @@ export default class HeapSnapshot implements IHeapSnapshot {
     _firstRetainerIndex: Uint32Array;
     _edgeIndex2SrcNodeIndex: Uint32Array;
     constructor(snapshot: RawHeapSnapshot, _options?: Record<string, never>);
+    getJSONifyableObject(): AnyRecord;
+    toJSONString(...args: Array<AnyValue>): string;
     hasObjectWithClassName(className: string): boolean;
     getAnyObjectWithClassName(className: string): Nullable<IHeapNode>;
     hasObjectWithPropertyName(nameOrIndex: string | number): boolean;