@dynatrace/react-native-plugin 2.331.1 → 2.333.1

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;

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

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapDetectedRoots = void 0;
+const jsc = require("jscodeshift");
+const Config_1 = require("./Config");
+const Types_1 = require("./Types");
+const DT_CFG_NAME = 'DT_ANALYTICS_CONFIG';
+const ensureReactImportAST = (j, root) => {
+    const has = root
+        .find(j.ImportDeclaration, { source: { value: 'react' } })
+        .filter((p) => (p.node.specifiers || []).some((s) => {
+        var _a, _b;
+        return (j.ImportDefaultSpecifier.check(s) &&
+            ((_a = s.local) === null || _a === void 0 ? void 0 : _a.name) === 'React') ||
+            (j.ImportNamespaceSpecifier.check(s) &&
+                ((_b = s.local) === null || _b === void 0 ? void 0 : _b.name) === 'React');
+    }))
+        .size() > 0;
+    if (has) {
+        return;
+    }
+    const firstImport = root.find(j.ImportDeclaration).at(0);
+    const imp = j.importDeclaration([j.importNamespaceSpecifier(j.identifier('React'))], j.literal('react'));
+    if (firstImport.size() > 0) {
+        firstImport.insertBefore(imp);
+    }
+    else {
+        root.get().node.program.body.unshift(imp);
+    }
+};
+const ensureRuntimeImportAST = (j, root) => {
+    const from = Types_1.Literals.DefaultRuntimeImport;
+    const has = root
+        .find(j.ImportDeclaration, { source: { value: from } })
+        .filter((p) => (p.node.specifiers || []).some((s) => {
+        var _a;
+        return j.ImportSpecifier.check(s) &&
+            ((_a = s.imported) === null || _a === void 0 ? void 0 : _a.name) === 'AnalyticsRoot';
+    }))
+        .size() > 0;
+    if (has) {
+        return;
+    }
+    const decl = j.importDeclaration([j.importSpecifier(j.identifier('AnalyticsRoot'))], j.literal(from));
+    const firstImport = root.find(j.ImportDeclaration).at(0);
+    if (firstImport.size() > 0) {
+        firstImport.insertBefore(decl);
+    }
+    else {
+        root.get().node.program.body.unshift(decl);
+    }
+};
+const valueToExpression = (j, v) => {
+    if (v === null) {
+        return j.nullLiteral();
+    }
+    const t = typeof v;
+    if (t === 'string' || t === 'number' || t === 'boolean') {
+        return j.literal(v);
+    }
+    if (Array.isArray(v)) {
+        return j.arrayExpression(v.map((x) => valueToExpression(j, x)));
+    }
+    if (t === 'object') {
+        return j.objectExpression(Object.keys(v).map((k) => j.objectProperty(j.identifier(k), valueToExpression(j, v[k]))));
+    }
+    return j.nullLiteral();
+};
+const ensureConfigConstAST = (j, root) => {
+    const exists = root
+        .find(j.VariableDeclaration)
+        .filter((p) => (p.node.declarations || []).some((d) => j.VariableDeclarator.check(d) &&
+        j.Identifier.check(d.id) &&
+        d.id.name === DT_CFG_NAME))
+        .size() > 0;
+    if (exists) {
+        return;
+    }
+    const init = valueToExpression(j, Config_1.DT_UII_ROOT_CONFIG);
+    const decl = j.variableDeclaration('const', [
+        j.variableDeclarator(j.identifier(DT_CFG_NAME), init),
+    ]);
+    const firstImport = root.find(j.ImportDeclaration).at(0);
+    if (firstImport.size() > 0) {
+        firstImport.insertAfter(decl);
+    }
+    else {
+        root.get().node.program.body.unshift(decl);
+    }
+};
+const isCreateAnalyticsRoot = (j, n) => j.CallExpression.check(n) &&
+    j.MemberExpression.check(n.callee) &&
+    j.Identifier.check(n.callee.object) &&
+    n.callee.object.name === 'React' &&
+    j.Identifier.check(n.callee.property) &&
+    n.callee.property.name === 'createElement' &&
+    n.arguments.length >= 1 &&
+    j.Identifier.check(n.arguments[0]) &&
+    n.arguments[0].name === 'AnalyticsRoot';
+const funcBodyContainsAnalyticsRoot = (j, f) => {
+    if (!j.ArrowFunctionExpression.check(f) && !j.FunctionExpression.check(f)) {
+        return false;
+    }
+    if (j.BlockStatement.check(f.body)) {
+        let found = false;
+        j(f.body)
+            .find(j.CallExpression)
+            .forEach((p) => {
+            if (isCreateAnalyticsRoot(j, p.node)) {
+                found = true;
+            }
+        });
+        return found;
+    }
+    else {
+        return isCreateAnalyticsRoot(j, f.body);
+    }
+};
+const createAnalyticsWrappedElement = (j, componentExpr, propsId) => j.callExpression(j.memberExpression(j.identifier('React'), j.identifier('createElement')), [
+    j.identifier('AnalyticsRoot'),
+    j.objectExpression([
+        j.property('init', j.identifier('name'), j.literal('App')),
+        j.property('init', j.identifier('config'), j.identifier(DT_CFG_NAME)),
+    ]),
+    j.callExpression(j.memberExpression(j.identifier('React'), j.identifier('createElement')), [
+        componentExpr,
+        propsId ? j.identifier(propsId) : j.nullLiteral(),
+    ]),
+]);
+const makeWrappedFactoryArrow = (j, innerCreateExpr) => j.arrowFunctionExpression([], j.blockStatement([
+    j.returnStatement(j.functionExpression(j.identifier('Wrapped'), [j.identifier('props')], j.blockStatement([
+        j.returnStatement(j.callExpression(j.memberExpression(j.identifier('React'), j.identifier('createElement')), [
+            j.identifier('AnalyticsRoot'),
+            j.objectExpression([
+                j.property('init', j.identifier('name'), j.literal('App')),
+                j.property('init', j.identifier('config'), j.identifier(DT_CFG_NAME)),
+            ]),
+            j.callExpression(j.memberExpression(j.identifier('React'), j.identifier('createElement')), [
+                innerCreateExpr,
+                j.identifier('props'),
+            ]),
+        ])),
+    ]))),
+]));
+const wrapExpoRegister = (j, callPath) => {
+    var _a;
+    const a0 = (_a = callPath.node.arguments) === null || _a === void 0 ? void 0 : _a[0];
+    if (!a0) {
+        return false;
+    }
+    if (j.ArrowFunctionExpression.check(a0) || j.FunctionExpression.check(a0)) {
+        if (funcBodyContainsAnalyticsRoot(j, a0)) {
+            return false;
+        }
+    }
+    if (j.Identifier.check(a0)) {
+        const inner = createAnalyticsWrappedElement(j, j.identifier(a0.name));
+        callPath.node.arguments[0] = j.arrowFunctionExpression([], inner);
+        return true;
+    }
+    if (j.ArrowFunctionExpression.check(a0) || j.FunctionExpression.check(a0)) {
+        const res = j.callExpression(a0, []);
+        const inner = createAnalyticsWrappedElement(j, res);
+        callPath.node.arguments[0] = j.arrowFunctionExpression([], inner);
+        return true;
+    }
+    if (j.JSXElement.check(a0) || j.CallExpression.check(a0)) {
+        const inner = createAnalyticsWrappedElement(j, a0);
+        callPath.node.arguments[0] = j.arrowFunctionExpression([], inner);
+        return true;
+    }
+    return false;
+};
+const wrapRNRegister = (j, callPath) => {
+    var _a;
+    const facArg = (_a = callPath.node.arguments) === null || _a === void 0 ? void 0 : _a[1];
+    if (!facArg) {
+        return false;
+    }
+    if (j.ArrowFunctionExpression.check(facArg) ||
+        j.FunctionExpression.check(facArg)) {
+        if (funcBodyContainsAnalyticsRoot(j, facArg)) {
+            return false;
+        }
+        const body = j.BlockStatement.check(facArg.body)
+            ? j.callExpression(facArg, [])
+            : facArg.body;
+        const chooseComp = j.conditionalExpression(j.callExpression(j.memberExpression(j.identifier('React'), j.identifier('isValidElement')), [body]), j.arrowFunctionExpression([], body), body);
+        callPath.node.arguments[1] = makeWrappedFactoryArrow(j, chooseComp);
+        return true;
+    }
+    if (j.Identifier.check(facArg) || j.MemberExpression.check(facArg)) {
+        const callComp = j.callExpression(facArg, []);
+        const chooseComp = j.conditionalExpression(j.callExpression(j.memberExpression(j.identifier('React'), j.identifier('isValidElement')), [callComp]), j.arrowFunctionExpression([], callComp), callComp);
+        callPath.node.arguments[1] = makeWrappedFactoryArrow(j, chooseComp);
+        return true;
+    }
+    if (j.JSXElement.check(facArg) || j.CallExpression.check(facArg)) {
+        const elem = j.ArrowFunctionExpression.check(facArg)
+            ? facArg.body
+            : facArg;
+        const chooseComp = j.arrowFunctionExpression([], elem);
+        callPath.node.arguments[1] = makeWrappedFactoryArrow(j, chooseComp);
+        return true;
+    }
+    return false;
+};
+const wrapDetectedRoots = (root, regs) => {
+    const j = jsc.withParser('tsx');
+    let changed = false;
+    if (!regs.length) {
+        return { root, changed };
+    }
+    ensureReactImportAST(j, root);
+    ensureRuntimeImportAST(j, root);
+    ensureConfigConstAST(j, root);
+    regs.forEach((r) => {
+        if (r.type === 'expo_register') {
+            const ok = wrapExpoRegister(j, r.path);
+            if (ok) {
+                changed = true;
+            }
+        }
+        else if (r.type === 'rn_register') {
+            const ok = wrapRNRegister(j, r.path);
+            if (ok) {
+                changed = true;
+            }
+        }
+        else {
+            changed = changed || false;
+        }
+    });
+    return { root, changed };
+};
+exports.wrapDetectedRoots = wrapDetectedRoots;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDTUserInteraction = void 0;
+const Config_1 = require("./Config");
+const Plugin_1 = require("./Plugin");
+const RootDetection_1 = require("./RootDetection");
+const RootWrapper_1 = require("./RootWrapper");
+const runDTUserInteraction = (root, filename, dynatraceOptions) => {
+    var _a;
+    const dtUiEnabled = (dynatraceOptions === null || dynatraceOptions === void 0 ? void 0 : dynatraceOptions.userInteraction) === true;
+    if (!dtUiEnabled) {
+        return { root, modified: false };
+    }
+    const shouldInjectPressableImport = typeof ((_a = dynatraceOptions === null || dynatraceOptions === void 0 ? void 0 : dynatraceOptions.input) === null || _a === void 0 ? void 0 : _a.instrument) === 'function'
+        ? dynatraceOptions.input.instrument(filename) !== false
+        : true;
+    let modified = false;
+    const regs = (0, RootDetection_1.detectRootRegistrations)(root, filename);
+    if (regs.length) {
+        const r = (0, RootWrapper_1.wrapDetectedRoots)(root, regs);
+        root = r.root;
+        if (r.changed) {
+            modified = true;
+        }
+    }
+    const mergedDT = Object.assign(Object.assign({}, (0, Config_1.getDTConfig)()), { shouldInjectPressableImport });
+    const dt = (0, Plugin_1.default)(root, filename, mergedDT);
+    root = dt.root;
+    if (dt.changed) {
+        modified = true;
+    }
+    return { root, modified };
+};
+exports.runDTUserInteraction = runDTUserInteraction;