@memlab/cli 1.0.6 → 1.0.10

package/dist/commands/heap/interactive/ui-components/HeapViewController.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ *
+ * @format
+ * @oncall ws_labs
+ */
+import type { IHeapSnapshot, IHeapNode } from '@memlab/core';
+import type ListComponent from './ListComponent';
+import { ComponentDataItem, ComponentData } from './HeapViewUtils';
+declare type SelectHeapObjectOption = {
+    noChangeInReferenceBox?: boolean;
+    noChangeInReferrerBox?: boolean;
+    noChangeInRetainerTraceBox?: boolean;
+    noChangeInObjectPropertyBox?: boolean;
+};
+/**
+ * HeapViewController managers all the data associated with each
+ * UI components in CLI and coordinates the events/interaction
+ * among all UI components.
+ */
+export default class HeapViewController {
+    private currentHeapObject;
+    private selectedHeapObject;
+    private currentHeapObjectsInfo;
+    private componentIdToDataMap;
+    private componentIdToComponentMap;
+    private heap;
+    private parentBox;
+    private referrerBox;
+    private objectBox;
+    private referenceBox;
+    private objectPropertyBox;
+    private retainerTracePropertyBox;
+    constructor(heap: IHeapSnapshot, nodes: ComponentDataItem[]);
+    getContent(componentId: number): string[];
+    setParentBox(component: ListComponent): void;
+    setReferrerBox(component: ListComponent): void;
+    getReferrerBoxData(node?: IHeapNode): ComponentData;
+    setObjectBox(component: ListComponent): void;
+    getObjectBoxData(): ComponentData;
+    setReferenceBox(component: ListComponent): void;
+    getReferenceBoxData(): ComponentData;
+    setObjectPropertyBox(component: ListComponent): void;
+    getObjectPropertyData(): ComponentData;
+    private getKeyValuePairString;
+    setRetainerTraceBox(component: ListComponent): void;
+    getRetainerTraceData(): ComponentData;
+    setCurrentHeapObjectFromComponent(componentId: number, itemIndex: number): void;
+    setCurrentHeapObject(node: IHeapNode): void;
+    focusOnComponent(componentId: number): void;
+    setSelectedHeapObjectFromComponent(componentId: number, itemIndex: number): void;
+    setSelectedHeapObject(node: IHeapNode, options?: SelectHeapObjectOption): void;
+}
+export {};
+//# sourceMappingURL=HeapViewController.d.ts.map

package/dist/commands/heap/interactive/ui-components/HeapViewController.js

@@ -0,0 +1,251 @@
+"use strict";
+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 HeapViewUtils_1 = require("./HeapViewUtils");
+/**
+ * HeapViewController managers all the data associated with each
+ * UI components in CLI and coordinates the events/interaction
+ * among all UI components.
+ */
+class HeapViewController {
+    constructor(heap, nodes) {
+        this.heap = heap;
+        this.currentHeapObject = (0, HeapViewUtils_1.getHeapObjectAt)(nodes, 0);
+        this.currentHeapObjectsInfo = nodes;
+        this.componentIdToDataMap = new Map();
+        this.componentIdToComponentMap = new Map();
+    }
+    getContent(componentId) {
+        const ret = [];
+        const data = this.componentIdToDataMap.get(componentId);
+        if (data) {
+            for (const item of data.items) {
+                ret.push(HeapViewUtils_1.ComponentDataItem.getTextForDisplay(item));
+            }
+        }
+        return ret;
+    }
+    setParentBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.parentBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    setReferrerBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.referrerBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getReferrerBoxData(node = this.selectedHeapObject) {
+        const data = new HeapViewUtils_1.ComponentData();
+        node.forEachReferrer(ref => {
+            var _a, _b;
+            const tag = ref.fromNode.id === ((_b = (_a = node.pathEdge) === null || _a === void 0 ? void 0 : _a.fromNode) === null || _b === void 0 ? void 0 : _b.id) ? { tag: '<-' } : {};
+            data.items.push(Object.assign({ heapObject: ref.fromNode, referenceEdge: ref }, tag));
+            return { stop: false };
+        });
+        data.selectedIdx = data.items.length > 0 ? 0 : -1;
+        return data;
+    }
+    setObjectBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.objectBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getObjectBoxData() {
+        const data = new HeapViewUtils_1.ComponentData();
+        const index = this.currentHeapObjectsInfo.findIndex(item => { var _a; return ((_a = item.heapObject) === null || _a === void 0 ? void 0 : _a.id) === this.currentHeapObject.id; });
+        if (index >= 0) {
+            data.selectedIdx = index;
+        }
+        else {
+            data.selectedIdx = 0;
+            this.currentHeapObjectsInfo.unshift({
+                tag: 'Chosen',
+                heapObject: this.currentHeapObject,
+            });
+        }
+        data.items = this.currentHeapObjectsInfo;
+        return data;
+    }
+    setReferenceBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.referenceBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getReferenceBoxData() {
+        const data = new HeapViewUtils_1.ComponentData();
+        this.selectedHeapObject.forEachReference(ref => {
+            data.items.push({ referrerEdge: ref, heapObject: ref.toNode });
+            return { stop: false };
+        });
+        data.selectedIdx = data.items.length > 0 ? 0 : -1;
+        return data;
+    }
+    setObjectPropertyBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.objectPropertyBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getObjectPropertyData() {
+        const data = new HeapViewUtils_1.ComponentData();
+        const node = this.selectedHeapObject;
+        data.items.push({
+            stringContent: this.getKeyValuePairString('id', `@${node.id}`),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('name', node.name),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('type', node.type),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('self size', core_1.utils.getReadableBytes(node.self_size)),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('retained size', core_1.utils.getReadableBytes(node.retainedSize)),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('# of references', core_1.utils.getReadableBytes(node.edge_count)),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('# of referrers', core_1.utils.getReadableBytes(node.referrers.length)),
+        });
+        if (node.dominatorNode) {
+            data.items.push({
+                stringContent: 'dominator node' + chalk_1.default.grey(': '),
+                heapObject: node.dominatorNode,
+            });
+        }
+        data.selectedIdx = data.items.length > 0 ? 0 : -1;
+        return data;
+    }
+    getKeyValuePairString(key, value) {
+        return key + chalk_1.default.grey(': ') + chalk_1.default.green(value);
+    }
+    setRetainerTraceBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.retainerTracePropertyBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getRetainerTraceData() {
+        var _a;
+        const data = new HeapViewUtils_1.ComponentData();
+        const node = this.selectedHeapObject;
+        let curNode = node;
+        while (curNode && !core_1.utils.isRootNode(curNode)) {
+            if (!curNode.pathEdge) {
+                curNode = null;
+                break;
+            }
+            data.items.unshift({ referrerEdge: curNode.pathEdge, heapObject: curNode });
+            curNode = (_a = curNode.pathEdge) === null || _a === void 0 ? void 0 : _a.fromNode;
+        }
+        if (curNode) {
+            data.items.unshift({ heapObject: curNode });
+        }
+        data.selectedIdx = data.items.length > 0 ? 0 : -1;
+        return data;
+    }
+    setCurrentHeapObjectFromComponent(componentId, itemIndex) {
+        const data = this.componentIdToDataMap.get(componentId);
+        if (!data) {
+            return;
+        }
+        const item = data.items[itemIndex];
+        if (!item) {
+            return;
+        }
+        const heapObject = item.heapObject;
+        if (!heapObject) {
+            return;
+        }
+        this.setCurrentHeapObject(heapObject);
+    }
+    setCurrentHeapObject(node) {
+        this.currentHeapObject = node;
+        // set parent box's data and content
+        const parentBoxData = this.getReferrerBoxData(this.currentHeapObject);
+        this.componentIdToDataMap.set(this.parentBox.id, parentBoxData);
+        this.parentBox.setContent(this.getContent(this.parentBox.id));
+        this.parentBox.selectIndex(parentBoxData.selectedIdx);
+        // set object box's data and content
+        const objectBoxData = this.getObjectBoxData();
+        this.componentIdToDataMap.set(this.objectBox.id, objectBoxData);
+        this.objectBox.setContent(this.getContent(this.objectBox.id));
+        this.objectBox.selectIndex(objectBoxData.selectedIdx);
+        this.setSelectedHeapObject(node);
+        this.focusOnComponent(this.objectBox.id);
+    }
+    focusOnComponent(componentId) {
+        for (const component of this.componentIdToComponentMap.values()) {
+            if (component.id === componentId) {
+                component.focus();
+            }
+            else {
+                component.loseFocus();
+            }
+        }
+    }
+    setSelectedHeapObjectFromComponent(componentId, itemIndex) {
+        const data = this.componentIdToDataMap.get(componentId);
+        if (!data) {
+            return;
+        }
+        data.selectedIdx = itemIndex;
+        const item = data.items[itemIndex];
+        if (!item) {
+            return;
+        }
+        const heapObject = item.heapObject;
+        if (!heapObject) {
+            return;
+        }
+        // if selecting in a specific box, do not update content in that box
+        const noChangeInReferenceBox = componentId === this.referenceBox.id;
+        const noChangeInReferrerBox = componentId === this.referrerBox.id;
+        const noChangeInRetainerTraceBox = componentId === this.retainerTracePropertyBox.id;
+        const noChangeInObjectPropertyBox = componentId === this.objectPropertyBox.id;
+        this.setSelectedHeapObject(heapObject, {
+            noChangeInReferenceBox,
+            noChangeInReferrerBox,
+            noChangeInRetainerTraceBox,
+            noChangeInObjectPropertyBox,
+        });
+    }
+    setSelectedHeapObject(node, options = {}) {
+        this.selectedHeapObject = node;
+        // set referrer box's data and content
+        if (!options.noChangeInReferrerBox) {
+            const data = this.getReferrerBoxData();
+            this.componentIdToDataMap.set(this.referrerBox.id, data);
+            this.referrerBox.setContent(this.getContent(this.referrerBox.id));
+            this.referrerBox.selectIndex(data.selectedIdx);
+        }
+        // set reference box's data and content
+        if (!options.noChangeInReferenceBox) {
+            const data = this.getReferenceBoxData();
+            this.componentIdToDataMap.set(this.referenceBox.id, data);
+            this.referenceBox.setContent(this.getContent(this.referenceBox.id));
+            this.referenceBox.selectIndex(data.selectedIdx);
+        }
+        // set object property box's data and content
+        if (!options.noChangeInObjectPropertyBox) {
+            const data = this.getObjectPropertyData();
+            this.componentIdToDataMap.set(this.objectPropertyBox.id, data);
+            this.objectPropertyBox.setContent(this.getContent(this.objectPropertyBox.id));
+            this.objectPropertyBox.selectIndex(data.selectedIdx);
+        }
+        // set retainer trace box's data and content
+        if (!options.noChangeInRetainerTraceBox) {
+            const data = this.getRetainerTraceData();
+            this.componentIdToDataMap.set(this.retainerTracePropertyBox.id, data);
+            this.retainerTracePropertyBox.setContent(this.getContent(this.retainerTracePropertyBox.id));
+            this.retainerTracePropertyBox.selectIndex(data.selectedIdx);
+        }
+    }
+}
+exports.default = HeapViewController;

package/dist/commands/heap/interactive/ui-components/HeapViewUtils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { IHeapEdge, IHeapNode } from '@memlab/core';
+export declare class ComponentDataItem {
+    stringContent?: string;
+    tag?: string;
+    referrerEdge?: IHeapEdge;
+    heapObject?: IHeapNode;
+    referenceEdge?: IHeapEdge;
+    type?: string;
+    static getTextForDisplay(data: ComponentDataItem): string;
+}
+export declare class ComponentData {
+    selectedIdx: number;
+    items: ComponentDataItem[];
+}
+export declare function throwIfNodesEmpty(nodes: ComponentDataItem[]): boolean;
+export declare function getHeapObjectAt(nodes: ComponentDataItem[], index: number): IHeapNode;
+export declare type DebounceCallback = () => void;
+export declare type DebounceFunction = (callback: DebounceCallback) => void;
+export declare function debounce(timeInMs: number): DebounceFunction;
+//# sourceMappingURL=HeapViewUtils.d.ts.map

package/dist/commands/heap/interactive/ui-components/HeapViewUtils.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = exports.getHeapObjectAt = exports.throwIfNodesEmpty = exports.ComponentData = exports.ComponentDataItem = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const core_1 = require("@memlab/core");
+class ComponentDataItem {
+    static getTextForDisplay(data) {
+        let ret = '';
+        if (data.tag) {
+            ret += `[${data.tag}] `;
+        }
+        if (data.stringContent) {
+            ret += data.stringContent;
+        }
+        const arrowPrefix = chalk_1.default.grey('--');
+        const arrowSuffix = chalk_1.default.grey('---') + '>';
+        if (data.referrerEdge) {
+            const edgeType = chalk_1.default.grey(`(${data.referrerEdge.type})`);
+            const edgeName = data.referrerEdge.name_or_index;
+            ret += `${arrowPrefix}${edgeName}${edgeType}${arrowSuffix} `;
+        }
+        if (data.heapObject) {
+            const objectType = chalk_1.default.grey(`(${data.heapObject.type})`);
+            const objectId = chalk_1.default.grey(` @${data.heapObject.id}`);
+            const size = core_1.utils.getReadableBytes(data.heapObject.retainedSize);
+            const sizeInfo = chalk_1.default.grey(' [') + chalk_1.default.bold(chalk_1.default.blue(size)) + chalk_1.default.grey(']');
+            ret +=
+                chalk_1.default.green(`[${data.heapObject.name}]`) +
+                    objectType +
+                    objectId +
+                    sizeInfo;
+        }
+        if (data.referenceEdge) {
+            const edgeType = chalk_1.default.grey(`(${data.referenceEdge.type})`);
+            const edgeName = data.referenceEdge.name_or_index;
+            ret += ` ${arrowPrefix}${edgeName}${edgeType}${arrowSuffix} `;
+        }
+        return ret === '' ? chalk_1.default.grey('<undefinied>') : ret;
+    }
+}
+exports.ComponentDataItem = ComponentDataItem;
+class ComponentData {
+    constructor() {
+        this.selectedIdx = -1;
+        this.items = [];
+    }
+}
+exports.ComponentData = ComponentData;
+function throwIfNodesEmpty(nodes) {
+    if (nodes.length === 0) {
+        throw core_1.utils.haltOrThrow('no heap node specified');
+    }
+    for (let i = 0; i < nodes.length; ++i) {
+        if (!nodes[i].heapObject) {
+            throw core_1.utils.haltOrThrow('heap node missing in ComponentDataItem[]');
+        }
+    }
+    return true;
+}
+exports.throwIfNodesEmpty = throwIfNodesEmpty;
+function getHeapObjectAt(nodes, index) {
+    throwIfNodesEmpty(nodes);
+    if (index < 0 || index >= nodes.length) {
+        throw core_1.utils.haltOrThrow('index is outside of nodes range');
+    }
+    return nodes[index].heapObject;
+}
+exports.getHeapObjectAt = getHeapObjectAt;
+function debounce(timeInMs) {
+    let id = null;
+    return (callback) => {
+        if (id) {
+            clearTimeout(id);
+        }
+        id = setTimeout(() => {
+            callback();
+            id = null;
+        }, timeInMs);
+    };
+}
+exports.debounce = debounce;

package/dist/commands/heap/interactive/ui-components/ListComponent.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ *
+ * @format
+ * @oncall ws_labs
+ */
+import type { Widgets } from 'blessed';
+export declare type ListComponentOption = {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    label: string;
+};
+export declare type ListItemSelectInfo = {
+    keyName: string;
+};
+export declare type ListCallbacks = {
+    selectCallback?: (componentId: number, index: number, content: string[], selectInfo: ListItemSelectInfo) => void;
+    updateContent?: (oldContent: string[], newContent: string[]) => void;
+    getFocus?: () => void;
+    render?: () => void;
+};
+/**
+ * A ListComponent is an UI list component in CLI.
+ * It managers all the UI events related to the
+ * list component (e.g., scroll up, down, left, right, and other key strokes)
+ */
+export default class ListComponent {
+    element: Widgets.ListElement;
+    id: number;
+    private listIndex;
+    private content;
+    private callbacks;
+    private horizonScrollPositionMap;
+    private displayedItems;
+    private moreEntryIndex;
+    private static readonly ListContentLimit;
+    private static readonly loadMore;
+    private static nextComponentId;
+    private static nextId;
+    constructor(content: string[], callbacks: ListCallbacks, options: ListComponentOption);
+    private render;
+    private static createEntryForMore;
+    protected registerKeys(): void;
+    private scrollLeft;
+    private scrollRight;
+    focus(): void;
+    loseFocus(): void;
+    selectIndex(index: number): void;
+    setContent(content: string[]): void;
+    loadMoreContent(): void;
+    private removeDisplayMoreEntry;
+    private insertDisplayMoreEntry;
+    updateContent(oldContent: string[], newContent: string[]): void;
+    getFocus(): void;
+    selectUpdate(index: number, content: string[], selectInfo: ListItemSelectInfo): void;
+}
+//# sourceMappingURL=ListComponent.d.ts.map