@memlab/cli 1.0.8 → 1.0.10

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

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

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const blessed_1 = __importDefault(require("blessed"));
+const chalk_1 = __importDefault(require("chalk"));
+const string_width_1 = __importDefault(require("string-width"));
+/**
+ * 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)
+ */
+class ListComponent {
+    constructor(content, callbacks, options) {
+        this.listIndex = 0;
+        this.content = [];
+        this.moreEntryIndex = -1;
+        this.id = ListComponent.nextId();
+        this.horizonScrollPositionMap = new Map();
+        this.callbacks = callbacks;
+        // init list element
+        this.element = blessed_1.default.list(Object.assign(Object.assign({}, options), { tags: true, scrollable: true, keys: true, border: {
+                fg: 'grey',
+                type: 'line',
+            }, style: {
+                item: {
+                    fg: 'white',
+                    bg: 'default',
+                },
+                selected: {
+                    bg: 'grey',
+                    bold: true,
+                },
+            } }));
+        this.setContent(content);
+        this.registerKeys();
+    }
+    static nextId() {
+        return ListComponent.nextComponentId++;
+    }
+    // render the whole screen
+    render() {
+        if (this.callbacks.render) {
+            this.callbacks.render();
+        }
+    }
+    static createEntryForMore(more) {
+        const key = chalk_1.default.inverse('enter');
+        return chalk_1.default.grey(` ${more} more ... (select and ${key} to load)`);
+    }
+    registerKeys() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        this.element.on('keypress', (char, key) => {
+            const content = self.content;
+            // if selecting "More"
+            if (key.name === 'enter' &&
+                content.length > 0 &&
+                self.listIndex >= 0 &&
+                self.listIndex === self.moreEntryIndex) {
+                self.loadMoreContent();
+                return;
+            }
+            // move selection down
+            if (key.name === 'down' && self.listIndex < self.displayedItems - 1) {
+                self.element.select(++self.listIndex);
+                self.selectUpdate(self.listIndex, content, {
+                    keyName: key.name,
+                });
+                // move selection up
+            }
+            else if (key.name === 'up' && self.listIndex > 0) {
+                self.element.select(--self.listIndex);
+                self.selectUpdate(self.listIndex, content, {
+                    keyName: key.name,
+                });
+                // hit enter to select the current heap object
+            }
+            else if (key.name === 'enter') {
+                self.selectUpdate(self.listIndex, content, {
+                    keyName: key.name,
+                });
+                // scroll left
+            }
+            else if (key.name === 'left') {
+                self.scrollLeft();
+                // scroll right
+            }
+            else if (key.name === 'right') {
+                self.scrollRight();
+            }
+        });
+    }
+    scrollLeft() {
+        var _a;
+        const selectedContent = this.content[this.listIndex];
+        if (!selectedContent) {
+            return;
+        }
+        let offset = 0;
+        if (this.horizonScrollPositionMap.has(this.listIndex)) {
+            offset = (_a = this.horizonScrollPositionMap.get(this.listIndex)) !== null && _a !== void 0 ? _a : 0;
+        }
+        if (offset === 0) {
+            return;
+        }
+        this.horizonScrollPositionMap.set(this.listIndex, --offset);
+        let newContent = selectedContent.substring(offset);
+        if (offset > 0) {
+            newContent = chalk_1.default.grey('...') + newContent;
+        }
+        this.element.spliceItem(this.listIndex, 1, newContent);
+        this.element.select(this.listIndex);
+    }
+    scrollRight() {
+        var _a;
+        const selectedContent = this.content[this.listIndex];
+        if (!selectedContent || (0, string_width_1.default)(selectedContent) <= 5) {
+            return;
+        }
+        let offset = 0;
+        if (this.horizonScrollPositionMap.has(this.listIndex)) {
+            offset = (_a = this.horizonScrollPositionMap.get(this.listIndex)) !== null && _a !== void 0 ? _a : 0;
+        }
+        this.horizonScrollPositionMap.set(this.listIndex, ++offset);
+        let newContent = selectedContent.substring(offset);
+        if (offset > 0) {
+            newContent = chalk_1.default.grey('...') + newContent;
+        }
+        this.element.spliceItem(this.listIndex, 1, newContent);
+        this.element.select(this.listIndex);
+    }
+    focus() {
+        this.element.focus();
+        this.element.style.border.fg = 'white';
+        this.getFocus();
+    }
+    loseFocus() {
+        this.element.style.border.fg = 'grey';
+    }
+    selectIndex(index) {
+        while (this.displayedItems <= index &&
+            this.displayedItems < this.content.length) {
+            this.loadMoreContent();
+        }
+        this.listIndex = index;
+        this.element.select(index);
+    }
+    setContent(content) {
+        const oldContent = this.content;
+        this.element.clearItems();
+        this.displayedItems = 0;
+        this.moreEntryIndex = -1;
+        this.listIndex = 0;
+        // push list items into the list
+        for (let i = 0; i < content.length; ++i) {
+            if (this.displayedItems >= ListComponent.ListContentLimit) {
+                break;
+            }
+            this.element.pushItem(content[i]);
+            ++this.displayedItems;
+        }
+        this.content = content;
+        this.horizonScrollPositionMap.clear();
+        this.insertDisplayMoreEntry();
+        this.updateContent(oldContent, this.content);
+    }
+    loadMoreContent() {
+        if (this.moreEntryIndex < 0) {
+            return;
+        }
+        const curIndex = this.listIndex;
+        this.removeDisplayMoreEntry();
+        let idx = this.displayedItems;
+        const limit = Math.min(this.displayedItems + ListComponent.loadMore, this.content.length);
+        while (idx < limit) {
+            this.element.pushItem(this.content[idx++]);
+        }
+        this.displayedItems = limit;
+        this.insertDisplayMoreEntry();
+        this.selectIndex(curIndex);
+        this.render();
+    }
+    removeDisplayMoreEntry() {
+        this.element.spliceItem(this.displayedItems - 1, 1);
+        this.moreEntryIndex = -1;
+        --this.displayedItems;
+        --this.listIndex;
+    }
+    // insert the display more entry
+    insertDisplayMoreEntry() {
+        if (this.displayedItems < this.content.length) {
+            this.element.pushItem(ListComponent.createEntryForMore(this.content.length - this.displayedItems));
+            ++this.displayedItems;
+            this.moreEntryIndex = this.displayedItems - 1;
+        }
+    }
+    // function to be overridden
+    updateContent(oldContent, newContent) {
+        if (this.callbacks.updateContent) {
+            this.callbacks.updateContent(oldContent, newContent);
+        }
+    }
+    // function to be overridden
+    getFocus() {
+        if (this.callbacks.getFocus) {
+            this.callbacks.getFocus();
+        }
+    }
+    selectUpdate(index, content, selectInfo) {
+        if (this.callbacks.selectCallback) {
+            this.callbacks.selectCallback(this.id, index, content, selectInfo);
+        }
+    }
+}
+exports.default = ListComponent;
+ListComponent.ListContentLimit = 100;
+ListComponent.loadMore = 20;
+ListComponent.nextComponentId = 0;

package/dist/commands/helper/GenerateCLIDocCommand.d.ts

@@ -4,8 +4,8 @@
  * 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
+ * @oncall ws_labs
  */
 import type { CLIOptions } from '@memlab/core';
 import BaseCommand from '../../BaseCommand';

package/dist/commands/helper/GenerateCLIDocCommand.js

@@ -5,8 +5,8 @@
  * 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
+ * @oncall ws_labs
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/dist/commands/helper/HelperCommand.d.ts

@@ -4,8 +4,8 @@
  * 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
+ * @oncall ws_labs
  */
 import type { BaseOption, CLIOptions } from '@memlab/core';
 import BaseCommand from '../../BaseCommand';

package/dist/commands/helper/HelperCommand.js

@@ -5,8 +5,8 @@
  * 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
+ * @oncall ws_labs
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;