@dynatrace/react-native-plugin 2.331.1 → 2.335.1

package/lib/dynatrace-reporter.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
 const TerminalReporter = (() => {
     try {
         return require('metro/src/lib/TerminalReporter');
@@ -24,19 +23,6 @@ const paths = require('../scripts/PathsConstants');
 const reporter = new TerminalReporter(new Terminal(process.stdout));
 const updateOrig = TerminalReporter.prototype.update;
 TerminalReporter.prototype.update = function update(event) {
-    if ((event === null || event === void 0 ? void 0 : event.type) === 'bundle_build_done') {
-        (0, child_process_1.exec)('npx lineOffsetDynatrace env prod', (error, stdout, stderr) => {
-            if (error) {
-                console.error(`Error: ${error.message}`);
-                return;
-            }
-            if (stderr) {
-                console.error(`stderr: ${stderr}`);
-                return;
-            }
-            console.log(`${stdout}`);
-        });
-    }
     return updateOrig === null || updateOrig === void 0 ? void 0 : updateOrig.apply(this, arguments);
 };
 const update = (event) => __awaiter(void 0, void 0, void 0, function* () {

package/lib/dynatrace-transformer.js

@@ -1,24 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUpstreamTransformer = exports.transform = void 0;
-const nodePath = require("path");
-const PathsConstants_1 = require("../scripts/PathsConstants");
 const config = require("../scripts/Config");
 const Logger_1 = require("../scripts/Logger");
-const CustomArgumentUtil_1 = require("../scripts/util/CustomArgumentUtil");
+const BabelPluginDynatrace_1 = require("../instrumentation/BabelPluginDynatrace");
 const instrumentor = require("../instrumentation/DynatraceInstrumentation");
-const customArguments = (0, CustomArgumentUtil_1.readCustomArguments)();
-const transform = (src, filename, options) => {
-    if (typeof src === 'object') {
-        ({ src, filename, options } = src);
-    }
+const Config_1 = require("../scripts/Config");
+const transform = (args) => {
+    var _a;
+    let src = args.src;
+    const { filename, options } = args;
     let reactOptions;
     try {
-        if (customArguments.isCustomConfigurationPathSet()) {
-            reactOptions = config.readConfig(nodePath.join(PathsConstants_1.default.getApplicationPath(), customArguments.getCustomConfigurationPath()));
-        }
-        else {
-            reactOptions = config.readConfig(nodePath.join(PathsConstants_1.default.getConfigFilePath()));
+        reactOptions = (0, Config_1.readConfigDefault)();
+        if (!reactOptions.react.useLegacyJscodeshift) {
+            args.plugins = [BabelPluginDynatrace_1.default, ...((_a = args.plugins) !== null && _a !== void 0 ? _a : [])];
+            return (0, exports.getUpstreamTransformer)(reactOptions === null || reactOptions === void 0 ? void 0 : reactOptions.react).transform(args);
         }
         src = instrumentor.instrument(src, filename, reactOptions.react);
     }

package/lib/features/ui-interaction/Config.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DT_UII_ROOT_CONFIG = exports.getDTConfig = exports.DEFAULT_DT_CONFIG = void 0;
+const Types_1 = require("./Types");
+exports.DEFAULT_DT_CONFIG = {
+    log: true,
+    artifactsDir: Types_1.Literals.DefaultArtifactsDir,
+    runtimeImport: Types_1.Literals.DefaultRuntimeImport,
+    componentNames: {
+        root: Types_1.Literals.DefaultRootName,
+    },
+    ui: {
+        skipTags: ['NavigationContainer'],
+        pathId: {
+            enabled: true,
+            propName: 'dtPathID',
+            uiRootPropName: 'dtUIRoot',
+            injectUiRoot: false,
+            skipProviderTags: true,
+            blacklist: ['AnalyticsRoot', 'Stack', 'React.Fragment', 'Fragment'],
+        },
+    },
+};
+const getDTConfig = () => exports.DEFAULT_DT_CONFIG;
+exports.getDTConfig = getDTConfig;
+exports.DT_UII_ROOT_CONFIG = {
+    path: {
+        withRole: true,
+        withIndex: true,
+        indexMode: 'global',
+        indexStyle: 'bracket',
+        withSid: false,
+        separator: '/',
+    },
+    mask: {
+        replaceWith: '***',
+        testID: (id) => /email|phone/i.test(id),
+        text: (s) => s.length > 20,
+    },
+    click: { capturePosition: 'page' },
+    touch: { enabled: true, mode: 'grouped' },
+};

package/lib/features/ui-interaction/IUserInteractionEvent.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserInteractionEventKey = void 0;
+var UserInteractionEventKey;
+(function (UserInteractionEventKey) {
+    UserInteractionEventKey["EventHasUserInteraction"] = "characteristics.has_user_interaction";
+    UserInteractionEventKey["UiElementDetectedName"] = "ui_element.detected_name";
+    UserInteractionEventKey["UiElementComponents"] = "ui_element.components";
+    UserInteractionEventKey["UiElementId"] = "ui_element.id";
+    UserInteractionEventKey["UiElementNameOrigin"] = "ui_element.name_origin";
+    UserInteractionEventKey["InteractionType"] = "interaction.type";
+    UserInteractionEventKey["UiElementResponderDetectedName"] = "ui_element.responder.detected_name";
+    UserInteractionEventKey["UiElementResponderComponents"] = "ui_element.responder.components";
+    UserInteractionEventKey["UiElementResponderOriginName"] = "ui_element.responder.name_origin";
+    UserInteractionEventKey["UiElementResponderId"] = "ui_element.responder.id";
+})(UserInteractionEventKey = exports.UserInteractionEventKey || (exports.UserInteractionEventKey = {}));

package/lib/features/ui-interaction/Plugin.Fragment.Test.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsc = require("jscodeshift");
+const Plugin_1 = require("./Plugin");
+const j = jsc.withParser('tsx');
+const runPlugin = (src, filename = 'FragmentCase.tsx') => {
+    const root = j(src);
+    const out = (0, Plugin_1.applyDTPathIdInstrumentation)(root, filename);
+    return out.root.toSource({ quote: 'single' });
+};
+describe('UI interaction Fragment blacklist', () => {
+    it('does not inject dtUIRoot by default', () => {
+        const code = runPlugin(`
+            import React from 'react';
+            import { View, Text } from 'react-native';
+
+            export default function Screen() {
+                return (
+                    <View>
+                        <Text>Hello</Text>
+                    </View>
+                );
+            }
+        `);
+        expect(code).toContain('<View dtPathID=');
+        expect(code).not.toContain('dtUIRoot');
+    });
+    it('does not instrument React.Fragment', () => {
+        const code = runPlugin(`
+            import React from 'react';
+            import { View, Text } from 'react-native';
+
+            export default function Screen() {
+                return (
+                    <View>
+                        <React.Fragment>
+                            <Text>Hello</Text>
+                        </React.Fragment>
+                    </View>
+                );
+            }
+        `);
+        expect(code).toContain('<React.Fragment>');
+        expect(code).not.toContain('<React.Fragment dtPathID=');
+        expect(code).toContain('<View dtPathID=');
+        expect(code).toContain('<Text dtPathID=');
+    });
+    it('does not instrument imported Fragment', () => {
+        const code = runPlugin(`
+            import React, { Fragment } from 'react';
+            import { View, Text } from 'react-native';
+
+            export default function Screen() {
+                return (
+                    <View>
+                        <Fragment>
+                            <Text>Hello</Text>
+                        </Fragment>
+                    </View>
+                );
+            }
+        `);
+        expect(code).toContain('<Fragment>');
+        expect(code).not.toContain('<Fragment dtPathID=');
+        expect(code).toContain('<View dtPathID=');
+        expect(code).toContain('<Text dtPathID=');
+    });
+    it('does not instrument aliased Fragment imports', () => {
+        const code = runPlugin(`
+            import React, { Fragment as F } from 'react';
+            import { View, Text } from 'react-native';
+
+            export default function Screen() {
+                return (
+                    <View>
+                        <F>
+                            <Text>Hello</Text>
+                        </F>
+                    </View>
+                );
+            }
+        `);
+        expect(code).toContain('<F>');
+        expect(code).not.toContain('<F dtPathID=');
+        expect(code).toContain('<View dtPathID=');
+        expect(code).toContain('<Text dtPathID=');
+    });
+    it('does not instrument empty fragment tags', () => {
+        const code = runPlugin(`
+            import React from 'react';
+            import { View, Text } from 'react-native';
+
+            export default function Screen() {
+                return (
+                    <>
+                        <View>
+                            <Text>Hello</Text>
+                        </View>
+                    </>
+                );
+            }
+        `);
+        expect(code).toContain('<>');
+        expect(code).toContain('<View dtPathID=');
+        expect(code).toContain('<Text dtPathID=');
+    });
+    it('removes existing dtPathID from React.Fragment JSX', () => {
+        const code = runPlugin(`
+            import React from 'react';
+            export default function Screen() {
+                return <React.Fragment dtPathID='bad'>Hello</React.Fragment>;
+            }
+        `);
+        expect(code).toContain('<React.Fragment>');
+        expect(code).not.toContain('dtPathID=');
+    });
+    it('removes dtPathID from transpiled jsx Fragment call', () => {
+        const code = runPlugin(`
+            import { Fragment as _Fragment, jsx as _jsx } from 'react/jsx-runtime';
+            export default function Screen() {
+                return _jsx(_Fragment, { dtPathID: 'bad', children: 'Hello' });
+            }
+        `);
+        expect(code).toContain('_jsx(_Fragment');
+        expect(code).not.toContain('dtPathID');
+    });
+    it('removes dtPathID from transpiled jsxDEV Fragment call', () => {
+        const code = runPlugin(`
+            import { Fragment as _Fragment, jsxDEV as _jsxDEV } from 'react/jsx-dev-runtime';
+            export default function Screen() {
+                return _jsxDEV(_Fragment, { dtPathID: 'bad', children: 'Hello' }, void 0, false, void 0, this);
+            }
+        `);
+        expect(code).toContain('_jsxDEV(_Fragment');
+        expect(code).not.toContain('dtPathID');
+    });
+    it('does not instrument Stack elements', () => {
+        const code = runPlugin(`
+            import React from 'react';
+            import { Stack } from 'expo-router';
+            import { View, Text } from 'react-native';
+
+            export default function Screen() {
+                return (
+                    <View>
+                        <Stack>
+                            <Text>Hello</Text>
+                        </Stack>
+                    </View>
+                );
+            }
+        `);
+        expect(code).toContain('<Stack>');
+        expect(code).not.toContain('<Stack dtPathID=');
+        expect(code).toContain('<View dtPathID=');
+        expect(code).toContain('<Text dtPathID=');
+    });
+    it('skips instrumentation for Expo package files', () => {
+        const src = `
+            import React from 'react';
+            import { View, Text } from 'react-native';
+            export default function Screen() {
+                return <View><Text>Hello</Text></View>;
+            }
+        `;
+        const code = runPlugin(src, 'node_modules/expo-router/build/qualified-entry.js');
+        expect(code).toEqual(j(src).toSource({ quote: 'single' }));
+        expect(code).not.toContain('dtPathID');
+    });
+});

package/lib/features/ui-interaction/Plugin.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDTPathIdInstrumentation = void 0;
+const fs = require("node:fs");
+const path = require("node:path");
+const micromatch_1 = require("micromatch");
+const jsc = require("jscodeshift");
+const Types_1 = require("./Types");
+const getName = (j, n) => {
+    if (j.JSXIdentifier.check(n)) {
+        return n.name;
+    }
+    if (j.JSXMemberExpression.check(n)) {
+        let c = n;
+        while (j.JSXMemberExpression.check(c)) {
+            c = c.property;
+        }
+        return j.JSXIdentifier.check(c) ? c.name : 'Anonymous';
+    }
+    return 'Anonymous';
+};
+const REACT_FRAGMENT_SOURCES = new Set([
+    'react',
+    'react/jsx-runtime',
+    'react/jsx-dev-runtime',
+]);
+const EXPO_PATH_SEGMENTS = [
+    'node_modules/expo/',
+    'node_modules/@expo/',
+    'node_modules/expo-router/',
+];
+const SELF_INSTRUMENTATION_PATH_SEGMENTS = [
+    'src/lib/features/ui-interaction/',
+    'lib/features/ui-interaction/',
+    'tests/lib/features/ui-interaction/',
+];
+const collectFragmentAliases = (root, j) => {
+    const fragmentAliases = new Set(['Fragment']);
+    root.find(j.ImportDeclaration).forEach((path) => {
+        const source = path.node.source;
+        if (!j.StringLiteral.check(source)) {
+            return;
+        }
+        if (!REACT_FRAGMENT_SOURCES.has(source.value)) {
+            return;
+        }
+        for (const specifier of path.node.specifiers || []) {
+            if (!j.ImportSpecifier.check(specifier)) {
+                continue;
+            }
+            const imported = specifier.imported;
+            if (!j.Identifier.check(imported) || imported.name !== 'Fragment') {
+                continue;
+            }
+            if (j.Identifier.check(specifier.local)) {
+                fragmentAliases.add(specifier.local.name);
+            }
+        }
+    });
+    return fragmentAliases;
+};
+const isFragmentName = (tagName, blacklist, fragmentAliases) => blacklist.has(tagName) || fragmentAliases.has(tagName);
+const isProviderLikeName = (tagName) => /Provider(?:Compat)?$/.test(tagName);
+const isLikelyJsxFactoryCall = (j, callee) => {
+    if (j.Identifier.check(callee)) {
+        return /jsx/i.test(callee.name);
+    }
+    if (j.MemberExpression.check(callee) &&
+        j.Identifier.check(callee.property)) {
+        return /jsx/i.test(callee.property.name);
+    }
+    return false;
+};
+const isFragmentExpression = (j, expr, fragmentAliases) => {
+    if (j.Identifier.check(expr)) {
+        return fragmentAliases.has(expr.name);
+    }
+    if (j.MemberExpression.check(expr) &&
+        expr.computed !== true &&
+        j.Identifier.check(expr.property)) {
+        return expr.property.name === 'Fragment';
+    }
+    return false;
+};
+const removePathIdFromObjectExpression = (j, objectExpression, propName) => {
+    if (!j.ObjectExpression.check(objectExpression)) {
+        return false;
+    }
+    const before = objectExpression.properties.length;
+    objectExpression.properties = objectExpression.properties.filter((property) => {
+        if (!j.ObjectProperty.check(property)) {
+            return true;
+        }
+        if (j.Identifier.check(property.key) &&
+            property.key.name === propName) {
+            return false;
+        }
+        return !(j.StringLiteral.check(property.key) &&
+            property.key.value === propName);
+    });
+    return objectExpression.properties.length !== before;
+};
+const shouldSkipFile = (filename, options) => {
+    var _a, _b;
+    const include = (_a = options.include) !== null && _a !== void 0 ? _a : [];
+    const exclude = (_b = options.exclude) !== null && _b !== void 0 ? _b : [];
+    const normalized = path.normalize(filename);
+    const normalizedPosix = normalized.split('\\').join('/');
+    if (include.length > 0 && !(0, micromatch_1.isMatch)(normalized, include)) {
+        return true;
+    }
+    if (EXPO_PATH_SEGMENTS.some((segment) => normalizedPosix.includes(segment))) {
+        return true;
+    }
+    if (SELF_INSTRUMENTATION_PATH_SEGMENTS.some((segment) => normalizedPosix.includes(segment))) {
+        return true;
+    }
+    return (0, micromatch_1.isMatch)(normalized, exclude);
+};
+const isPathInside = (baseDir, candidatePath) => {
+    const resolvedBase = path.resolve(baseDir);
+    const resolvedCandidate = path.resolve(candidatePath);
+    return (resolvedCandidate === resolvedBase ||
+        resolvedCandidate.startsWith(`${resolvedBase}${path.sep}`));
+};
+const writeArtifact = (root, filename, options) => {
+    var _a, _b;
+    const outDir = (_a = options.artifactsDir) !== null && _a !== void 0 ? _a : Types_1.Literals.DefaultArtifactsDir;
+    try {
+        const rel = path.relative(globalThis.process.cwd(), filename);
+        const outPath = path.resolve(outDir, rel);
+        if (!isPathInside(outDir, outPath)) {
+            return;
+        }
+        const code = root.toSource({ quote: 'single' });
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        fs.writeFileSync(outPath, code, 'utf8');
+    }
+    catch (e) {
+        if (options.log === true) {
+            const errorMsg = e instanceof Error ? (_b = e.stack) !== null && _b !== void 0 ? _b : e.message : String(e);
+            globalThis.console.log(`[UIInteractionPlugin]: Unable to write artifact for ${filename}: ${errorMsg}`);
+        }
+    }
+};
+const applyDTPathIdInstrumentation = (root, filename, options = {}) => {
+    var _a, _b, _c, _d;
+    const j = jsc.withParser('tsx');
+    if (shouldSkipFile(filename, options)) {
+        return { root, changed: false };
+    }
+    const uiOptions = ((_a = options.ui) !== null && _a !== void 0 ? _a : {});
+    const pathIdConfig = (_b = uiOptions.pathId) !== null && _b !== void 0 ? _b : {};
+    const enabled = pathIdConfig.enabled !== false;
+    if (!enabled) {
+        return { root, changed: false };
+    }
+    const propName = (_c = pathIdConfig.propName) !== null && _c !== void 0 ? _c : 'dtPathID';
+    const uiRootPropName = (_d = pathIdConfig.uiRootPropName) !== null && _d !== void 0 ? _d : 'dtUIRoot';
+    const injectUiRoot = pathIdConfig.injectUiRoot === true;
+    const skipProviderTags = pathIdConfig.skipProviderTags !== false;
+    const blacklist = new Set(pathIdConfig.blacklist || [
+        'AnalyticsRoot',
+        'Stack',
+        'React.Fragment',
+        'Fragment',
+    ]);
+    const fragmentAliases = collectFragmentAliases(root, j);
+    let seq = 0;
+    let changed = false;
+    let rootMarkerAssigned = false;
+    const getAttributes = (opening) => Array.isArray(opening.attributes) ? opening.attributes : [];
+    const hasAttribute = (opening, attrName) => {
+        const attrs = getAttributes(opening);
+        return attrs.some((attr) => j.JSXAttribute.check(attr) &&
+            j.JSXIdentifier.check(attr.name) &&
+            attr.name.name === attrName);
+    };
+    const hasPathIdAttribute = (opening) => hasAttribute(opening, propName);
+    const addBooleanAttribute = (opening, attrName) => {
+        opening.attributes = [
+            ...getAttributes(opening),
+            j.jsxAttribute(j.jsxIdentifier(attrName)),
+        ];
+    };
+    const removeAttribute = (opening, attrName) => {
+        const attrs = getAttributes(opening);
+        const filtered = attrs.filter((attr) => !(j.JSXAttribute.check(attr) &&
+            j.JSXIdentifier.check(attr.name) &&
+            attr.name.name === attrName));
+        if (filtered.length === attrs.length) {
+            return false;
+        }
+        opening.attributes = filtered;
+        return true;
+    };
+    const removePathIdAttribute = (opening) => removeAttribute(opening, propName);
+    const removeUiRootAttribute = (opening) => removeAttribute(opening, uiRootPropName);
+    const removeInstrumentationAttributes = (opening) => {
+        const removedPathId = removePathIdAttribute(opening);
+        const removedUiRoot = removeUiRootAttribute(opening);
+        return removedPathId || removedUiRoot;
+    };
+    const maybeAssignUiRoot = (opening, hasUiRootAttribute) => {
+        if (!injectUiRoot || rootMarkerAssigned || hasUiRootAttribute) {
+            return false;
+        }
+        addBooleanAttribute(opening, uiRootPropName);
+        rootMarkerAssigned = true;
+        return true;
+    };
+    const addPathIdAttribute = (opening, tagName) => {
+        var _a, _b, _c, _d;
+        const baseName = Array.from(tagName)
+            .map((ch) => (/\w/.test(ch) ? ch : '_'))
+            .join('') || 'Anonymous';
+        const line = (_b = (_a = opening.loc) === null || _a === void 0 ? void 0 : _a.start) === null || _b === void 0 ? void 0 : _b.line;
+        const column = (_d = (_c = opening.loc) === null || _c === void 0 ? void 0 : _c.start) === null || _d === void 0 ? void 0 : _d.column;
+        const fallback = seq++;
+        const suffix = typeof line === 'number' && typeof column === 'number'
+            ? `${line}_${column}`
+            : `${fallback}_0`;
+        const dtPathId = `${baseName}_${suffix}`;
+        opening.attributes = [
+            ...getAttributes(opening),
+            j.jsxAttribute(j.jsxIdentifier(propName), j.stringLiteral(dtPathId)),
+        ];
+    };
+    const processOpeningElement = (opening) => {
+        const tagName = getName(j, opening.name);
+        const hasUiRootAttribute = hasAttribute(opening, uiRootPropName);
+        if (!injectUiRoot &&
+            hasUiRootAttribute &&
+            removeUiRootAttribute(opening)) {
+            changed = true;
+        }
+        if (skipProviderTags && isProviderLikeName(tagName)) {
+            if (removeInstrumentationAttributes(opening)) {
+                changed = true;
+            }
+            return;
+        }
+        if (injectUiRoot && hasUiRootAttribute) {
+            rootMarkerAssigned = true;
+        }
+        if (isFragmentName(tagName, blacklist, fragmentAliases)) {
+            if (removeInstrumentationAttributes(opening)) {
+                changed = true;
+            }
+            return;
+        }
+        if (hasPathIdAttribute(opening)) {
+            if (maybeAssignUiRoot(opening, hasUiRootAttribute)) {
+                changed = true;
+            }
+            return;
+        }
+        addPathIdAttribute(opening, tagName);
+        if (maybeAssignUiRoot(opening, hasUiRootAttribute)) {
+            changed = true;
+        }
+        changed = true;
+    };
+    root.find(j.JSXOpeningElement).forEach((path) => {
+        processOpeningElement(path.node);
+    });
+    root.find(j.CallExpression).forEach((path) => {
+        const call = path.node;
+        if (!isLikelyJsxFactoryCall(j, call.callee)) {
+            return;
+        }
+        const [typeArg, propsArg] = call.arguments;
+        if (!isFragmentExpression(j, typeArg, fragmentAliases) ||
+            propsArg === undefined ||
+            !j.ObjectExpression.check(propsArg)) {
+            return;
+        }
+        if (removePathIdFromObjectExpression(j, propsArg, propName)) {
+            changed = true;
+        }
+    });
+    if (changed) {
+        writeArtifact(root, filename, options);
+    }
+    return { root, changed };
+};
+exports.applyDTPathIdInstrumentation = applyDTPathIdInstrumentation;
+const applyDTUserInteraction = exports.applyDTPathIdInstrumentation;
+exports.default = applyDTUserInteraction;

package/lib/features/ui-interaction/RootDetection.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRootRegistrations = void 0;
+const j = require("jscodeshift");
+const isProjectFile = (filename) => filename && !/\/node_modules\//.test(filename);
+const detectRootRegistrations = (root, filename) => {
+    if (!isProjectFile(filename)) {
+        return [];
+    }
+    const regs = [];
+    root.find(j.ImportDeclaration).forEach((p) => {
+        const importSource = (p.node.source.value || '');
+        if (importSource === 'expo-router' ||
+            importSource === 'expo-router/entry') {
+            regs.push({ type: 'expo_router_entry', path: p });
+        }
+    });
+    root.find(j.CallExpression, {
+        callee: { type: 'Identifier', name: 'registerRootComponent' },
+    }).forEach((p) => {
+        var _a;
+        const componentFactoryArg = (_a = p.node.arguments) === null || _a === void 0 ? void 0 : _a[0];
+        if (!componentFactoryArg) {
+            return;
+        }
+        regs.push({
+            type: 'expo_register',
+            path: p,
+        });
+    });
+    root.find(j.CallExpression, {
+        callee: {
+            type: 'MemberExpression',
+            object: { type: 'Identifier', name: 'AppRegistry' },
+            property: { type: 'Identifier', name: 'registerComponent' },
+        },
+    }).forEach((p) => {
+        var _a, _b;
+        const appNameArg = (_a = p.node.arguments) === null || _a === void 0 ? void 0 : _a[0];
+        const componentFactoryArg = (_b = p.node.arguments) === null || _b === void 0 ? void 0 : _b[1];
+        if (!appNameArg || !componentFactoryArg) {
+            return;
+        }
+        regs.push({
+            type: 'rn_register',
+            path: p,
+        });
+    });
+    return regs;
+};
+exports.detectRootRegistrations = detectRootRegistrations;