@memlab/heap-analysis 1.0.0

package/dist/plugins/GlobalVariableAnalysis/GlobalVariableAnalysis.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { HeapAnalysisOptions } from '../../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../../BaseAnalysis';
+declare class GlobalVariableAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    process(options: HeapAnalysisOptions): Promise<void>;
+    private shouldFilterOutEdge;
+    private getGlobalVariables;
+}
+export default GlobalVariableAnalysis;
+//# sourceMappingURL=GlobalVariableAnalysis.d.ts.map

package/dist/plugins/GlobalVariableAnalysis/GlobalVariableAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalVariableAnalysis.d.ts","sourceRoot":"","sources":["../../../src/plugins/GlobalVariableAnalysis/GlobalVariableAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAExC,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAI9C,cAAM,sBAAuB,SAAQ,YAAY;IAC/C,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,UAAU,EAAE;IAIpB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1D,OAAO,CAAC,mBAAmB;IAkB3B,OAAO,CAAC,kBAAkB;CAoB3B;AAED,eAAe,sBAAsB,CAAC"}

package/dist/plugins/GlobalVariableAnalysis/GlobalVariableAnalysis.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../../options/HeapAnalysisSnapshotFileOption"));
+const BaseAnalysis_1 = __importDefault(require("../../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../../PluginUtils"));
+const BuiltInGlobalVariables_1 = __importDefault(require("./BuiltInGlobalVariables"));
+class GlobalVariableAnalysis extends BaseAnalysis_1.default {
+    getCommandName() {
+        return 'global-variable';
+    }
+    getDescription() {
+        return 'Get global variables in heap';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
+            const list = this.getGlobalVariables(snapshot);
+            PluginUtils_1.default.printReferencesInTerminal(list);
+        });
+    }
+    shouldFilterOutEdge(edge) {
+        if (BuiltInGlobalVariables_1.default.has(`${edge.name_or_index}`)) {
+            return true;
+        }
+        const toNodeType = edge.toNode.type;
+        if (edge.name_or_index === '<symbol>') {
+            return true;
+        }
+        if (toNodeType === 'hidden' ||
+            toNodeType === 'array' ||
+            toNodeType === 'number') {
+            return true;
+        }
+        return false;
+    }
+    getGlobalVariables(snapshot) {
+        // rank heap objects based on fanout
+        const ret = [];
+        const processNode = (node) => {
+            if (!node.name.startsWith('Window ')) {
+                return;
+            }
+            const refs = node.references;
+            for (const edge of refs) {
+                if (!this.shouldFilterOutEdge(edge)) {
+                    ret.push(edge);
+                }
+            }
+        };
+        snapshot.nodes.forEach(processNode);
+        return ret.sort((e1, e2) => e2.toNode.retainedSize - e1.toNode.retainedSize);
+    }
+}
+exports.default = GlobalVariableAnalysis;

package/dist/plugins/ObjectFanoutAnalysis.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+declare class ObjectFanoutAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    process(options: HeapAnalysisOptions): Promise<void>;
+    private getObjectsWithHighFanout;
+}
+export default ObjectFanoutAnalysis;
+//# sourceMappingURL=ObjectFanoutAnalysis.d.ts.map

package/dist/plugins/ObjectFanoutAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectFanoutAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/ObjectFanoutAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAIxD,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAI3C,cAAM,oBAAqB,SAAQ,YAAY;IAC7C,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,UAAU,EAAE;IAIpB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1D,OAAO,CAAC,wBAAwB;CA2BjC;AAED,eAAe,oBAAoB,CAAC"}

package/dist/plugins/ObjectFanoutAnalysis.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
+class ObjectFanoutAnalysis extends BaseAnalysis_1.default {
+    getCommandName() {
+        return 'object-fanout';
+    }
+    getDescription() {
+        return 'Get objects with the most out-going references in heap';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
+            const list = this.getObjectsWithHighFanout(snapshot, options.args);
+            PluginUtils_1.default.printNodeListInTerminal(list);
+        });
+    }
+    getObjectsWithHighFanout(snapshot, args) {
+        // rank heap objects based on fanout
+        let ret = [];
+        const listSize = args.listSize || 20;
+        snapshot.nodes.forEach(node => {
+            if (!PluginUtils_1.default.isNodeWorthInspecting(node)) {
+                return;
+            }
+            const count = PluginUtils_1.default.getObjectOutgoingEdgeCount(node);
+            let i;
+            for (i = ret.length - 1; i >= 0; --i) {
+                const curCnt = PluginUtils_1.default.getObjectOutgoingEdgeCount(ret[i]);
+                if (curCnt >= count) {
+                    ret.splice(i + 1, 0, node);
+                    break;
+                }
+            }
+            if (i < 0) {
+                ret.unshift(node);
+            }
+            ret = ret.slice(0, listSize);
+        });
+        return ret;
+    }
+}
+exports.default = ObjectFanoutAnalysis;

package/dist/plugins/ObjectShallowAnalysis.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+declare type ObjectRecord = {
+    n: number;
+    size: number;
+    ids: string[];
+    obj: string;
+};
+declare class ObjectShallowAnalysis extends BaseAnalysis {
+    private topDupObjInCnt;
+    private topDupObjInCntListSize;
+    private topDupObjInSize;
+    private topDupObjInSizeListSize;
+    private objectPatternsStat;
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    process(options: HeapAnalysisOptions): Promise<void>;
+    getTopDuplicatedObjectInCount(): ObjectRecord[];
+    private getPreprocessedObjectMap;
+    private nodeToObject;
+    private static objectPatternsToObserve;
+    private shouldIgnoreNode;
+    private textEllipsis;
+    private rankRecords;
+    private calculateTopDuplicatedObjectsInCount;
+    private calculateTopDuplicatedObjectsInSize;
+    private calculateobjectPatternsStatistics;
+    private print;
+}
+export default ObjectShallowAnalysis;
+//# sourceMappingURL=ObjectShallowAnalysis.d.ts.map

package/dist/plugins/ObjectShallowAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectShallowAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/ObjectShallowAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAGxD,OAAO,EAAc,UAAU,EAAY,MAAM,cAAc,CAAC;AAChE,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAS3C,aAAK,YAAY,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAiBF,cAAM,qBAAsB,SAAQ,YAAY;IAC9C,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,sBAAsB,CAAM;IACpC,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,uBAAuB,CAAM;IACrC,OAAO,CAAC,kBAAkB,CAAyB;IAEnD,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,UAAU,EAAE;IAIpB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IASnD,6BAA6B,IAAI,YAAY,EAAE;IAItD,OAAO,CAAC,wBAAwB;IAyBhC,OAAO,CAAC,YAAY;IA0BpB,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAGpC;IAEF,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,WAAW;IA0BnB,OAAO,CAAC,oCAAoC;IAS5C,OAAO,CAAC,mCAAmC;IAS3C,OAAO,CAAC,iCAAiC;IA6BzC,OAAO,CAAC,KAAK;CA8Cd;AAED,eAAe,qBAAqB,CAAC"}

package/dist/plugins/ObjectShallowAnalysis.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const core_1 = require("@memlab/core");
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
+class ObjectShallowAnalysis extends BaseAnalysis_1.default {
+    constructor() {
+        super(...arguments);
+        this.topDupObjInCnt = [];
+        this.topDupObjInCntListSize = 10;
+        this.topDupObjInSize = [];
+        this.topDupObjInSizeListSize = 10;
+        this.objectPatternsStat = {};
+    }
+    getCommandName() {
+        return 'object-shallow';
+    }
+    getDescription() {
+        return 'Get objects by key and value, without recursing into sub-objects';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
+            const objectMap = this.getPreprocessedObjectMap(snapshot);
+            this.calculateobjectPatternsStatistics(objectMap);
+            this.calculateTopDuplicatedObjectsInCount(objectMap);
+            this.calculateTopDuplicatedObjectsInSize(objectMap);
+            this.print();
+        });
+    }
+    getTopDuplicatedObjectInCount() {
+        return this.topDupObjInCnt;
+    }
+    getPreprocessedObjectMap(snapshot) {
+        core_1.info.overwrite('building object map...');
+        const objectMap = Object.create(null);
+        snapshot.nodes.forEach((node) => {
+            if (this.shouldIgnoreNode(node)) {
+                return;
+            }
+            const obj = this.nodeToObject(node);
+            const value = JSON.stringify(obj);
+            objectMap[value] = objectMap[value] || {
+                n: 0,
+                size: 0,
+                ids: [],
+                obj: JSON.stringify(obj),
+            };
+            const record = objectMap[value];
+            ++record.n;
+            record.size += node.retainedSize;
+            record.ids.push(node.id);
+        });
+        return objectMap;
+    }
+    nodeToObject(node) {
+        const result = {};
+        for (const edge of node.references) {
+            if (edge.type === 'property' && edge.name_or_index != '__proto__') {
+                const key = edge.name_or_index;
+                const value = edge.toNode;
+                if (core_1.utils.isStringNode(value)) {
+                    result[key] = core_1.utils.getStringNodeValue(edge.toNode);
+                }
+                else if (value.type === 'number') {
+                    result[key] = core_1.utils.getNumberNodeValue(edge.toNode);
+                }
+                else if (value.type === 'boolean') {
+                    result[key] = core_1.utils.getBooleanNodeValue(edge.toNode);
+                }
+                else {
+                    // shallow analysis, just put the id as a string
+                    result[key] = 'REFERENCE_' + value.id;
+                }
+            }
+        }
+        return { class: node.name, object: result };
+    }
+    shouldIgnoreNode(node) {
+        let hasAHiddenReferrer = false;
+        node.forEachReferrer((edge) => {
+            if (edge.type === 'hidden') {
+                hasAHiddenReferrer = true;
+                return { stop: true };
+            }
+        });
+        return !(!hasAHiddenReferrer &&
+            node.type === 'object' &&
+            node.name !== 'Array' &&
+            node.name !== 'ArrayBuffer' &&
+            node.name !== 'Set' &&
+            node.name !== 'Map' &&
+            !node.name.startsWith('Window') &&
+            !node.name.startsWith('system /'));
+    }
+    textEllipsis(str, maxLength, { side = 'end', ellipsis = '...' } = {}) {
+        if (str.length > maxLength) {
+            switch (side) {
+                case 'start':
+                    return ellipsis + str.slice(-(maxLength - ellipsis.length));
+                case 'end':
+                default:
+                    return str.slice(0, maxLength - ellipsis.length) + ellipsis;
+            }
+        }
+        return str;
+    }
+    rankRecords(objectMap, compare, listSize) {
+        let rank = [];
+        for (const [, record] of Object.entries(objectMap)) {
+            if (record.n <= 1) {
+                continue; // only care about duplicated objects
+            }
+            let i = 0;
+            for (i = rank.length - 1; i >= 0; --i) {
+                const item = rank[i];
+                if (compare(item, record) >= 0) {
+                    rank.splice(i + 1, 0, record);
+                    break;
+                }
+            }
+            if (i < 0) {
+                rank.unshift(record);
+            }
+            rank = rank.slice(0, listSize);
+        }
+        return rank;
+    }
+    calculateTopDuplicatedObjectsInCount(objectMap) {
+        core_1.info.overwrite('calculating top duplicated objects in count...');
+        this.topDupObjInCnt = this.rankRecords(objectMap, (item1, item2) => item1.n - item2.n, this.topDupObjInCntListSize);
+    }
+    calculateTopDuplicatedObjectsInSize(objectMap) {
+        core_1.info.overwrite('calculating top duplicated objects in size...');
+        this.topDupObjInSize = this.rankRecords(objectMap, (item1, item2) => item1.size - item2.size, this.topDupObjInSizeListSize);
+    }
+    calculateobjectPatternsStatistics(objectMap) {
+        core_1.info.overwrite('calculating statistics for specified object patterns...');
+        const objectPatternStat = Object.create(null);
+        for (const [str, record] of Object.entries(objectMap)) {
+            patternLoop: for (const [patternName, patternCheck] of Object.entries(ObjectShallowAnalysis.objectPatternsToObserve)) {
+                if (!patternCheck(str)) {
+                    continue patternLoop;
+                }
+                objectPatternStat[patternName] = objectPatternStat[patternName] || {
+                    n: 0,
+                    dupN: 0,
+                    size: 0,
+                    dupSize: 0,
+                };
+                const item = objectPatternStat[patternName];
+                item.n += record.n;
+                item.size += record.size;
+                if (record.n > 1) {
+                    item.dupN += record.n - 1;
+                    item.dupSize += (record.size * (record.n - 1)) / record.n;
+                }
+            }
+        }
+        this.objectPatternsStat = objectPatternStat;
+    }
+    print() {
+        const sep = chalk_1.default.grey(', ');
+        const colon = chalk_1.default.grey(': ');
+        const beg = chalk_1.default.grey('[');
+        const end = chalk_1.default.grey(']');
+        const dot = chalk_1.default.grey('·');
+        const head = chalk_1.default.yellow.bind(chalk_1.default);
+        // print statistics of specified object patterns
+        for (const [str, item] of Object.entries(this.objectPatternsStat)) {
+            core_1.info.topLevel(head(`\n${str}`));
+            let p = core_1.utils.getReadablePercent(item.dupN / item.n);
+            core_1.info.topLevel(`${dot}Count: ${item.n} (${p} are duplicated)`);
+            const size = core_1.utils.getReadableBytes(item.size);
+            p = core_1.utils.getReadablePercent(item.dupSize / item.size);
+            core_1.info.topLevel(`${dot}Size: ${size} (${p} are duplicated)`);
+        }
+        core_1.info.topLevel(head('\nTop duplicated objects in count'));
+        let len = Math.min(15, this.topDupObjInCnt.length);
+        for (let i = 0; i < len; ++i) {
+            const item = this.topDupObjInCnt[i];
+            const size = core_1.utils.getReadableBytes(item.size);
+            const str = `"${chalk_1.default.blue(this.textEllipsis(item.obj, 100))}"`;
+            core_1.info.topLevel(` ${dot}${beg}${item.n}${sep}${size}${end}${colon}${str}`);
+        }
+        len = Math.min(15, this.topDupObjInSize.length);
+        core_1.info.topLevel(head('\nTop duplicated objects in size:'));
+        for (let i = 0; i < len; ++i) {
+            const item = this.topDupObjInSize[i];
+            const size = core_1.utils.getReadableBytes(item.size);
+            const str = `"${chalk_1.default.blue(this.textEllipsis(item.obj, 100))}"`;
+            const exampleIds = item.ids.slice(0, 10).map((id) => `@${id}`);
+            let examples = exampleIds.join(', ');
+            if (exampleIds.length < item.ids.length) {
+                examples += ' ...';
+            }
+            examples = chalk_1.default.grey(examples);
+            core_1.info.topLevel(`\n ${dot}${beg}${size}${sep}${item.n}${end}${colon}${str}`);
+            core_1.info.topLevel(`    node examples: ${examples}`);
+        }
+    }
+}
+ObjectShallowAnalysis.objectPatternsToObserve = {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    'All objects': (_) => true,
+};
+exports.default = ObjectShallowAnalysis;

package/dist/plugins/ObjectShapeAnalysis.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+declare class ObjectShapeAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    process(options: HeapAnalysisOptions): Promise<void>;
+}
+export default ObjectShapeAnalysis;
+//# sourceMappingURL=ObjectShapeAnalysis.d.ts.map

package/dist/plugins/ObjectShapeAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectShapeAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/ObjectShapeAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAW,UAAU,EAAC,MAAM,cAAc,CAAC;AAClD,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAI3C,cAAM,mBAAoB,SAAQ,YAAY;IAC5C,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,UAAU,EAAE;IAIpB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAI3D;AAED,eAAe,mBAAmB,CAAC"}

package/dist/plugins/ObjectShapeAnalysis.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
+class ObjectShapeAnalysis extends BaseAnalysis_1.default {
+    getCommandName() {
+        return 'shape';
+    }
+    getDescription() {
+        return 'List the shapes that retained most memory';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshotPath = PluginUtils_1.default.getSnapshotFileForAnalysis(options);
+            yield core_1.analysis.breakDownMemoryByShapes({ file: snapshotPath });
+        });
+    }
+}
+exports.default = ObjectShapeAnalysis;

package/dist/plugins/ObjectSizeAnalysis.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+declare class ObjectSizeRankAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    process(options: HeapAnalysisOptions): Promise<void>;
+}
+export default ObjectSizeRankAnalysis;
+//# sourceMappingURL=ObjectSizeAnalysis.d.ts.map

package/dist/plugins/ObjectSizeAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectSizeAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/ObjectSizeAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAI3C,cAAM,sBAAuB,SAAQ,YAAY;IAC/C,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,UAAU,EAAE;IAIpB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ3D;AAED,eAAe,sBAAsB,CAAC"}

package/dist/plugins/ObjectSizeAnalysis.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
+class ObjectSizeRankAnalysis extends BaseAnalysis_1.default {
+    getCommandName() {
+        return 'object-size';
+    }
+    getDescription() {
+        return 'Get the largest objects in heap';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
+            const largeObjects = PluginUtils_1.default.filterOutLargestObjects(snapshot, PluginUtils_1.default.isNodeWorthInspecting);
+            PluginUtils_1.default.printNodeListInTerminal(largeObjects);
+        });
+    }
+}
+exports.default = ObjectSizeRankAnalysis;

package/dist/plugins/ObjectUnboundGrowthAnalysis.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+declare class ObjectUnboundGrowthAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    process(options: HeapAnalysisOptions): Promise<void>;
+}
+export default ObjectUnboundGrowthAnalysis;
+//# sourceMappingURL=ObjectUnboundGrowthAnalysis.d.ts.map

package/dist/plugins/ObjectUnboundGrowthAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectUnboundGrowthAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/ObjectUnboundGrowthAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAmB,UAAU,EAAC,MAAM,cAAc,CAAC;AAC1D,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAI3C,cAAM,2BAA4B,SAAQ,YAAY;IACpD,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,UAAU,EAAE;IAIpB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAM3D;AAED,eAAe,2BAA2B,CAAC"}