@memlab/core 1.1.20 → 1.1.21

package/dist/lib/Utils.js

@@ -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;
@@ -1782,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 '';
         }
@@ -1824,14 +1749,28 @@ function getNumberAtPercentile(arr, percentile) {
     }
     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,
@@ -1840,13 +1779,14 @@ exports.default = {
     extractHTMLElementNodeInfo,
     filterNodesInPlace,
     getAllDominators,
+    getBooleanNodeValue,
     getClosureSourceUrl,
     getConditionalDominatorIds,
-    getError,
     getEdgeByNameAndType,
+    getError,
     getLastNodeId,
-    getLeakedNode,
     getLeakTracePathLength,
+    getLeakedNode,
     getNodesIdSet,
     getNumberAtPercentile,
     getNumberNodeValue,
@@ -1854,17 +1794,16 @@ exports.default = {
     getReadablePercent,
     getReadableTime,
     getRetainedSize,
-    getRunMetaFilePath,
     getScenarioName,
     getSingleSnapshotFileForAnalysis,
     getSnapshotDirForAnalysis,
-    getSnapshotFilesInDir,
+    getSnapshotFilePath,
+    getSnapshotFilePathWithTabType,
     getSnapshotFilesFromTabsOrder,
+    getSnapshotFilesInDir,
     getSnapshotFromFile,
     getSnapshotNodeIdsFromFile,
     getSnapshotSequenceFilePath,
-    getSnapshotFilePath,
-    getSnapshotFilePathWithTabType,
     getStringNodeValue,
     getToNodeByEdge,
     getUniqueID,
@@ -1875,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,
@@ -1905,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,
@@ -1928,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,7 +30,7 @@ class MemoryBarChart {
             Console_1.default.warning(`plot data not load correctly: ${Utils_1.default.getError(ex).message}`);
             return;
         }
-        if (plotData.length === 0) {
+        if (!this.isPlotDataValid(plotData)) {
             if (Config_1.default.verbose) {
                 Console_1.default.warning('no memory usage data to plot');
             }
@@ -57,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)) {
@@ -82,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/trace-filters/BaseTraceFilter.rule.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { MemLabConfig } from '../Config';
+import type { HeapNodeIdSet, IHeapSnapshot, LeakTracePathItem } from '../Types';
+/**
+ * Every leak trace filter rule needs to give a label
+ * to each leak trace passed to the filter
+ */
+export declare enum TraceDecision {
+    INSIGHTFUL = "insightful",
+    MAYBE_INSIGHTFUL = "maybe-insightful",
+    NOT_INSIGHTFUL = "not-insightful"
+}
+export declare type LeakTraceFilterOptions = {
+    config?: MemLabConfig;
+    snapshot?: IHeapSnapshot;
+    leakedNodeIds?: HeapNodeIdSet;
+};
+export interface ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=BaseTraceFilter.rule.d.ts.map

package/dist/lib/trace-filters/BaseTraceFilter.rule.js

@@ -0,0 +1,22 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceDecision = void 0;
+/**
+ * Every leak trace filter rule needs to give a label
+ * to each leak trace passed to the filter
+ */
+var TraceDecision;
+(function (TraceDecision) {
+    TraceDecision["INSIGHTFUL"] = "insightful";
+    TraceDecision["MAYBE_INSIGHTFUL"] = "maybe-insightful";
+    TraceDecision["NOT_INSIGHTFUL"] = "not-insightful";
+})(TraceDecision = exports.TraceDecision || (exports.TraceDecision = {}));

package/dist/lib/trace-filters/LeakTraceFilter.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { LeakTracePathItem } from '../Types';
+import type { LeakTraceFilterOptions } from './BaseTraceFilter.rule';
+/**
+ * apply the leak trace filter rules chain and decide
+ * if a leak trace is useful for memory debugging,
+ * by default all leak traces are considered useful
+ */
+export declare class LeakTraceFilter {
+    filter(p: LeakTracePathItem, options: LeakTraceFilterOptions): boolean;
+}
+//# sourceMappingURL=LeakTraceFilter.d.ts.map

package/dist/lib/trace-filters/LeakTraceFilter.js

@@ -0,0 +1,37 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeakTraceFilter = void 0;
+const BaseTraceFilter_rule_1 = require("./BaseTraceFilter.rule");
+const TraceFilterRuleList_1 = __importDefault(require("./TraceFilterRuleList"));
+/**
+ * apply the leak trace filter rules chain and decide
+ * if a leak trace is useful for memory debugging,
+ * by default all leak traces are considered useful
+ */
+class LeakTraceFilter {
+    filter(p, options) {
+        for (const rule of TraceFilterRuleList_1.default) {
+            const decision = rule.filter(p, options);
+            if (decision === BaseTraceFilter_rule_1.TraceDecision.INSIGHTFUL) {
+                return true;
+            }
+            if (decision === BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.LeakTraceFilter = LeakTraceFilter;

package/dist/lib/trace-filters/TraceFilterRuleList.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 web_perf_infra
+ */
+import { ILeakTraceFilterRule } from './BaseTraceFilter.rule';
+declare const _default: ILeakTraceFilterRule[];
+export default _default;
+//# sourceMappingURL=TraceFilterRuleList.d.ts.map

package/dist/lib/trace-filters/TraceFilterRuleList.js

@@ -0,0 +1,33 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Constant_1 = __importDefault(require("../Constant"));
+const InternalValueSetter_1 = require("../InternalValueSetter");
+const FilterAttachedDOMToDetachedDOMTrace_rule_1 = require("./rules/FilterAttachedDOMToDetachedDOMTrace.rule");
+const FilterDOMNodeChainTrace_rule_1 = require("./rules/FilterDOMNodeChainTrace.rule");
+const FilterHermesTrace_rule_1 = require("./rules/FilterHermesTrace.rule");
+const FilterInternalNodeTrace_rule_1 = require("./rules/FilterInternalNodeTrace.rule");
+const FilterPendingActivitiesTrace_rule_1 = require("./rules/FilterPendingActivitiesTrace.rule");
+const FilterShadowRootTrace_rule_1 = require("./rules/FilterShadowRootTrace.rule");
+const FilterStyleEngineTrace_rule_1 = require("./rules/FilterStyleEngineTrace.rule");
+const list = [
+    new FilterHermesTrace_rule_1.FilterHermesTraceRule(),
+    new FilterInternalNodeTrace_rule_1.FilterInternalNodeTraceRule(),
+    new FilterShadowRootTrace_rule_1.FilterShadowRootTraceRule(),
+    new FilterStyleEngineTrace_rule_1.FilterStyleEngineTraceRule(),
+    new FilterPendingActivitiesTrace_rule_1.FilterPendingActivitiesTraceRule(),
+    new FilterDOMNodeChainTrace_rule_1.FilterDOMNodeChainTraceRule(),
+    new FilterAttachedDOMToDetachedDOMTrace_rule_1.FilterAttachedDOMToDetachedDOMTraceRule(),
+];
+exports.default = (0, InternalValueSetter_1.setInternalValue)(list, __filename, Constant_1.default.internalDir);

package/dist/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterAttachedDOMToDetachedDOMTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterAttachedDOMToDetachedDOMTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.js

@@ -0,0 +1,55 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterAttachedDOMToDetachedDOMTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterAttachedDOMToDetachedDOMTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path consists of only DOM native nodes/elements
+        if (curConfig.hideBrowserLeak && isAttachedDOMToDetachedDOMChain(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterAttachedDOMToDetachedDOMTraceRule = FilterAttachedDOMToDetachedDOMTraceRule;
+// check if the path has pattern:
+// [Attached Element] -> [InternalNode | Text]+ -> [Detached Element]
+function isAttachedDOMToDetachedDOMChain(path) {
+    if (!path) {
+        return false;
+    }
+    let p = path;
+    let hasEncounteredAttachedNode = false;
+    // skip the rest InternalNode
+    while (p != null && p.node) {
+        if (Utils_1.default.isDetachedDOMNode(p.node)) {
+            return hasEncounteredAttachedNode;
+        }
+        // else if this is an attached node
+        if (Utils_1.default.isDOMNodeIncomplete(p.node)) {
+            hasEncounteredAttachedNode = true;
+        }
+        else {
+            // else if this not a DOM element
+            hasEncounteredAttachedNode = false;
+        }
+        p = p.next;
+    }
+    return false;
+}

package/dist/lib/trace-filters/rules/FilterDOMNodeChainTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterDOMNodeChainTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterDOMNodeChainTrace.rule.d.ts.map