@truewatchtech/react-native-mobile-babel-plugin 0.4.3-alpha.1

package/lib/module/options.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["mergeOptions","options","componentOptions","components","actionNameAttribute","tracked","useContent","undefined","useNamePrefix"],"sources":["options.ts"],"sourcesContent":["/*\n * Portions of this file are adapted from Datadog's dd-sdk-reactnative Babel\n * interaction tracking implementation, licensed under Apache-2.0.\n */\n\nimport type { NormalizedPluginOptions, PluginOptions } from './types';\n\nexport function mergeOptions(\n  options: PluginOptions = {}\n): NormalizedPluginOptions {\n  const componentOptions = options.components || {};\n  return {\n    actionNameAttribute: options.actionNameAttribute,\n    components: {\n      tracked: componentOptions.tracked || [],\n      useContent:\n        componentOptions.useContent === undefined\n          ? true\n          : componentOptions.useContent,\n      useNamePrefix:\n        componentOptions.useNamePrefix === undefined\n          ? true\n          : componentOptions.useNamePrefix,\n    },\n  };\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;;AAIA,OAAO,SAASA,YAAYA,CAC1BC,OAAsB,GAAG,CAAC,CAAC,EACF;EACzB,MAAMC,gBAAgB,GAAGD,OAAO,CAACE,UAAU,IAAI,CAAC,CAAC;EACjD,OAAO;IACLC,mBAAmB,EAAEH,OAAO,CAACG,mBAAmB;IAChDD,UAAU,EAAE;MACVE,OAAO,EAAEH,gBAAgB,CAACG,OAAO,IAAI,EAAE;MACvCC,UAAU,EACRJ,gBAAgB,CAACI,UAAU,KAAKC,SAAS,GACrC,IAAI,GACJL,gBAAgB,CAACI,UAAU;MACjCE,aAAa,EACXN,gBAAgB,CAACM,aAAa,KAAKD,SAAS,GACxC,IAAI,GACJL,gBAAgB,CAACM;IACzB;EACF,CAAC;AACH","ignoreList":[]}

package/lib/module/state.js

@@ -0,0 +1,25 @@
+/*
+ * Portions of this file are adapted from Datadog's dd-sdk-reactnative Babel
+ * interaction tracking implementation, licensed under Apache-2.0.
+ */
+
+import { createTrackedComponents } from './actions/rum/components';
+export function isSkippedFile(state) {
+  var _state$file, _state$file2;
+  const caller = (_state$file = state.file) === null || _state$file === void 0 || (_state$file = _state$file.opts) === null || _state$file === void 0 ? void 0 : _state$file.caller;
+  const filename = state.filename || ((_state$file2 = state.file) === null || _state$file2 === void 0 || (_state$file2 = _state$file2.opts) === null || _state$file2 === void 0 ? void 0 : _state$file2.filename);
+  return (caller === null || caller === void 0 ? void 0 : caller.platform) === 'web' || Boolean(filename && filename.includes('node_modules'));
+}
+
+/** Initializes per-file state; identifiers and memoization never leak across files. */
+export function initializePluginState(t, programPath, state, options) {
+  state._ftTrackedComponents = createTrackedComponents(t, programPath, options);
+  state._ftCustomNames = new Set(options.components.tracked.map(component => component.name));
+  state._ftMemoizedHandlers = new Set();
+  state._ftHasWrappedAction = false;
+  state._ftNeedsContentRuntime = false;
+  state._ftExtractTextIdentifier = programPath.scope.generateUidIdentifier('ftExtractText');
+  state._ftReactIdentifier = programPath.scope.generateUidIdentifier('FTReact');
+  state._ftTrackingIdentifier = programPath.scope.generateUidIdentifier('FTBabelInteractionTracking');
+}
+//# sourceMappingURL=state.js.map

package/lib/module/state.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createTrackedComponents","isSkippedFile","state","_state$file","_state$file2","caller","file","opts","filename","platform","Boolean","includes","initializePluginState","t","programPath","options","_ftTrackedComponents","_ftCustomNames","Set","components","tracked","map","component","name","_ftMemoizedHandlers","_ftHasWrappedAction","_ftNeedsContentRuntime","_ftExtractTextIdentifier","scope","generateUidIdentifier","_ftReactIdentifier","_ftTrackingIdentifier"],"sources":["state.ts"],"sourcesContent":["/*\n * Portions of this file are adapted from Datadog's dd-sdk-reactnative Babel\n * interaction tracking implementation, licensed under Apache-2.0.\n */\n\nimport type * as Babel from '@babel/core';\nimport { createTrackedComponents } from './actions/rum/components';\nimport type { NormalizedPluginOptions, PluginState } from './types';\n\nexport function isSkippedFile(state: PluginState): boolean {\n  const caller = state.file?.opts?.caller as { platform?: string } | undefined;\n  const filename = state.filename || state.file?.opts?.filename;\n  return (\n    caller?.platform === 'web' ||\n    Boolean(filename && filename.includes('node_modules'))\n  );\n}\n\n/** Initializes per-file state; identifiers and memoization never leak across files. */\nexport function initializePluginState(\n  t: typeof Babel.types,\n  programPath: Babel.NodePath<Babel.types.Program>,\n  state: PluginState,\n  options: NormalizedPluginOptions\n): void {\n  state._ftTrackedComponents = createTrackedComponents(t, programPath, options);\n  state._ftCustomNames = new Set(\n    options.components.tracked.map((component) => component.name)\n  );\n  state._ftMemoizedHandlers = new Set();\n  state._ftHasWrappedAction = false;\n  state._ftNeedsContentRuntime = false;\n  state._ftExtractTextIdentifier =\n    programPath.scope.generateUidIdentifier('ftExtractText');\n  state._ftReactIdentifier = programPath.scope.generateUidIdentifier('FTReact');\n  state._ftTrackingIdentifier = programPath.scope.generateUidIdentifier(\n    'FTBabelInteractionTracking'\n  );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;;AAGA,SAASA,uBAAuB,QAAQ,0BAA0B;AAGlE,OAAO,SAASC,aAAaA,CAACC,KAAkB,EAAW;EAAA,IAAAC,WAAA,EAAAC,YAAA;EACzD,MAAMC,MAAM,IAAAF,WAAA,GAAGD,KAAK,CAACI,IAAI,cAAAH,WAAA,gBAAAA,WAAA,GAAVA,WAAA,CAAYI,IAAI,cAAAJ,WAAA,uBAAhBA,WAAA,CAAkBE,MAA2C;EAC5E,MAAMG,QAAQ,GAAGN,KAAK,CAACM,QAAQ,MAAAJ,YAAA,GAAIF,KAAK,CAACI,IAAI,cAAAF,YAAA,gBAAAA,YAAA,GAAVA,YAAA,CAAYG,IAAI,cAAAH,YAAA,uBAAhBA,YAAA,CAAkBI,QAAQ;EAC7D,OACE,CAAAH,MAAM,aAANA,MAAM,uBAANA,MAAM,CAAEI,QAAQ,MAAK,KAAK,IAC1BC,OAAO,CAACF,QAAQ,IAAIA,QAAQ,CAACG,QAAQ,CAAC,cAAc,CAAC,CAAC;AAE1D;;AAEA;AACA,OAAO,SAASC,qBAAqBA,CACnCC,CAAqB,EACrBC,WAAgD,EAChDZ,KAAkB,EAClBa,OAAgC,EAC1B;EACNb,KAAK,CAACc,oBAAoB,GAAGhB,uBAAuB,CAACa,CAAC,EAAEC,WAAW,EAAEC,OAAO,CAAC;EAC7Eb,KAAK,CAACe,cAAc,GAAG,IAAIC,GAAG,CAC5BH,OAAO,CAACI,UAAU,CAACC,OAAO,CAACC,GAAG,CAAEC,SAAS,IAAKA,SAAS,CAACC,IAAI,CAC9D,CAAC;EACDrB,KAAK,CAACsB,mBAAmB,GAAG,IAAIN,GAAG,CAAC,CAAC;EACrChB,KAAK,CAACuB,mBAAmB,GAAG,KAAK;EACjCvB,KAAK,CAACwB,sBAAsB,GAAG,KAAK;EACpCxB,KAAK,CAACyB,wBAAwB,GAC5Bb,WAAW,CAACc,KAAK,CAACC,qBAAqB,CAAC,eAAe,CAAC;EAC1D3B,KAAK,CAAC4B,kBAAkB,GAAGhB,WAAW,CAACc,KAAK,CAACC,qBAAqB,CAAC,SAAS,CAAC;EAC7E3B,KAAK,CAAC6B,qBAAqB,GAAGjB,WAAW,CAACc,KAAK,CAACC,qBAAqB,CACnE,4BACF,CAAC;AACH","ignoreList":[]}

package/lib/module/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["/*\n * Portions of this file are adapted from Datadog's dd-sdk-reactnative Babel\n * interaction tracking implementation, licensed under Apache-2.0.\n */\n\nimport type * as Babel from '@babel/core';\n\nexport type TrackedHandler = {\n  event: string;\n  actionType?: string;\n  mode?: 'default' | 'delayed';\n};\n\nexport type TrackedComponent = {\n  name: string;\n  useContent?: boolean;\n  useNamePrefix?: boolean;\n  contentProp?: string;\n  handlers: TrackedHandler[];\n};\n\nexport type PluginOptions = {\n  actionNameAttribute?: string;\n  components?: {\n    useContent?: boolean;\n    useNamePrefix?: boolean;\n    tracked?: TrackedComponent[];\n  };\n};\n\nexport type NormalizedPluginOptions = {\n  actionNameAttribute?: string;\n  components: {\n    useContent: boolean;\n    useNamePrefix: boolean;\n    tracked: TrackedComponent[];\n  };\n};\n\nexport type TrackedComponentData = Omit<TrackedComponent, 'name'> & {\n  importedName?: string;\n  isCustom: boolean;\n  useContent: boolean;\n  useNamePrefix: boolean;\n};\n\nexport type ActionMetadata = {\n  accessibilityLabels: Babel.types.StringLiteral[];\n  actionNames: Babel.types.StringLiteral[];\n  component: TrackedComponentData;\n  componentName: string;\n  customActionNames: Babel.types.StringLiteral[];\n  getContent: Babel.types.ArrowFunctionExpression | null;\n};\n\nexport type PluginState = Babel.PluginPass & {\n  _ftCustomNames: Set<string>;\n  _ftExtractTextIdentifier: Babel.types.Identifier;\n  _ftHasWrappedAction: boolean;\n  _ftMemoizedHandlers: Set<Babel.types.Node>;\n  _ftNeedsContentRuntime: boolean;\n  _ftReactIdentifier: Babel.types.Identifier;\n  _ftSkip: boolean;\n  _ftTrackedComponents: Record<string, TrackedComponentData>;\n  _ftTrackingIdentifier: Babel.types.Identifier;\n};\n\nexport type PluginAPI = typeof Babel & Babel.ConfigAPI;\n\nexport type JSXAttributePath = Babel.NodePath<\n  Babel.types.JSXAttribute | Babel.types.JSXSpreadAttribute\n>;\n"],"mappings":"","ignoreList":[]}

package/lib/module/utils/jsx.js

@@ -0,0 +1,36 @@
+/*
+ * Portions of this file are adapted from Datadog's dd-sdk-reactnative Babel
+ * interaction tracking implementation, licensed under Apache-2.0.
+ */
+
+export function getNodeName(t, node) {
+  if (!node) {
+    return null;
+  }
+  if (t.isIdentifier(node) || t.isJSXIdentifier(node)) {
+    return node.name;
+  }
+  if (t.isStringLiteral(node)) {
+    return node.value;
+  }
+  if (t.isJSXNamespacedName(node)) {
+    return `${node.namespace.name}:${node.name.name}`;
+  }
+  if (t.isJSXMemberExpression(node)) {
+    let nodeName = node.property.name;
+    let nodeTracker = node.object;
+    while (t.isJSXMemberExpression(nodeTracker)) {
+      nodeName = `${nodeTracker.property.name}.${nodeName}`;
+      nodeTracker = nodeTracker.object;
+    }
+    return t.isJSXIdentifier(nodeTracker) ? `${nodeTracker.name}.${nodeName}` : null;
+  }
+  if ('name' in node && node.name && typeof node.name !== 'string') {
+    return getNodeName(t, node.name);
+  }
+  return null;
+}
+export function getDirectAttributePaths(path) {
+  return path.get('openingElement.attributes');
+}
+//# sourceMappingURL=jsx.js.map

package/lib/module/utils/jsx.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getNodeName","t","node","isIdentifier","isJSXIdentifier","name","isStringLiteral","value","isJSXNamespacedName","namespace","isJSXMemberExpression","nodeName","property","nodeTracker","object","getDirectAttributePaths","path","get"],"sources":["jsx.ts"],"sourcesContent":["/*\n * Portions of this file are adapted from Datadog's dd-sdk-reactnative Babel\n * interaction tracking implementation, licensed under Apache-2.0.\n */\n\nimport type * as Babel from '@babel/core';\nimport type { JSXAttributePath } from '../types';\n\nexport function getNodeName(\n  t: typeof Babel.types,\n  node: Babel.types.Node | null | undefined\n): string | null {\n  if (!node) {\n    return null;\n  }\n  if (t.isIdentifier(node) || t.isJSXIdentifier(node)) {\n    return node.name;\n  }\n  if (t.isStringLiteral(node)) {\n    return node.value;\n  }\n  if (t.isJSXNamespacedName(node)) {\n    return `${node.namespace.name}:${node.name.name}`;\n  }\n  if (t.isJSXMemberExpression(node)) {\n    let nodeName = node.property.name;\n    let nodeTracker:\n      | Babel.types.JSXIdentifier\n      | Babel.types.JSXMemberExpression = node.object;\n\n    while (t.isJSXMemberExpression(nodeTracker)) {\n      nodeName = `${nodeTracker.property.name}.${nodeName}`;\n      nodeTracker = nodeTracker.object;\n    }\n\n    return t.isJSXIdentifier(nodeTracker)\n      ? `${nodeTracker.name}.${nodeName}`\n      : null;\n  }\n  if ('name' in node && node.name && typeof node.name !== 'string') {\n    return getNodeName(t, node.name);\n  }\n  return null;\n}\n\nexport function getDirectAttributePaths(\n  path: Babel.NodePath<Babel.types.JSXElement>\n): JSXAttributePath[] {\n  return path.get('openingElement.attributes') as JSXAttributePath[];\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;;AAKA,OAAO,SAASA,WAAWA,CACzBC,CAAqB,EACrBC,IAAyC,EAC1B;EACf,IAAI,CAACA,IAAI,EAAE;IACT,OAAO,IAAI;EACb;EACA,IAAID,CAAC,CAACE,YAAY,CAACD,IAAI,CAAC,IAAID,CAAC,CAACG,eAAe,CAACF,IAAI,CAAC,EAAE;IACnD,OAAOA,IAAI,CAACG,IAAI;EAClB;EACA,IAAIJ,CAAC,CAACK,eAAe,CAACJ,IAAI,CAAC,EAAE;IAC3B,OAAOA,IAAI,CAACK,KAAK;EACnB;EACA,IAAIN,CAAC,CAACO,mBAAmB,CAACN,IAAI,CAAC,EAAE;IAC/B,OAAO,GAAGA,IAAI,CAACO,SAAS,CAACJ,IAAI,IAAIH,IAAI,CAACG,IAAI,CAACA,IAAI,EAAE;EACnD;EACA,IAAIJ,CAAC,CAACS,qBAAqB,CAACR,IAAI,CAAC,EAAE;IACjC,IAAIS,QAAQ,GAAGT,IAAI,CAACU,QAAQ,CAACP,IAAI;IACjC,IAAIQ,WAE+B,GAAGX,IAAI,CAACY,MAAM;IAEjD,OAAOb,CAAC,CAACS,qBAAqB,CAACG,WAAW,CAAC,EAAE;MAC3CF,QAAQ,GAAG,GAAGE,WAAW,CAACD,QAAQ,CAACP,IAAI,IAAIM,QAAQ,EAAE;MACrDE,WAAW,GAAGA,WAAW,CAACC,MAAM;IAClC;IAEA,OAAOb,CAAC,CAACG,eAAe,CAACS,WAAW,CAAC,GACjC,GAAGA,WAAW,CAACR,IAAI,IAAIM,QAAQ,EAAE,GACjC,IAAI;EACV;EACA,IAAI,MAAM,IAAIT,IAAI,IAAIA,IAAI,CAACG,IAAI,IAAI,OAAOH,IAAI,CAACG,IAAI,KAAK,QAAQ,EAAE;IAChE,OAAOL,WAAW,CAACC,CAAC,EAAEC,IAAI,CAACG,IAAI,CAAC;EAClC;EACA,OAAO,IAAI;AACb;AAEA,OAAO,SAASU,uBAAuBA,CACrCC,IAA4C,EACxB;EACpB,OAAOA,IAAI,CAACC,GAAG,CAAC,2BAA2B,CAAC;AAC9C","ignoreList":[]}

package/lib/typescript/actions/global.d.ts

@@ -0,0 +1,2 @@
+import type * as Babel from '@babel/core';
+export declare function insertPluginEnabledFlag(t: typeof Babel.types, programPath: Babel.NodePath<Babel.types.Program>): void;

package/lib/typescript/actions/rum/components.d.ts

@@ -0,0 +1,5 @@
+import type * as Babel from '@babel/core';
+import type { NormalizedPluginOptions, TrackedComponentData } from '../../types';
+export declare function createTrackedComponents(t: typeof Babel.types, programPath: Babel.NodePath<Babel.types.Program>, options: NormalizedPluginOptions): Record<string, TrackedComponentData>;
+export declare function isInsideConfiguredComponent(t: typeof Babel.types, path: Babel.NodePath<Babel.types.JSXElement>, customComponentNames: Set<string>): boolean;
+export declare function addRequiredTextInputHandler(t: typeof Babel.types, path: Babel.NodePath<Babel.types.JSXElement>, component: TrackedComponentData, componentName: string): void;

package/lib/typescript/actions/rum/content.d.ts

@@ -0,0 +1,6 @@
+import type * as Babel from '@babel/core';
+import type { PluginState, TrackedComponentData } from '../../types';
+/** Checks whether moving content into a memo callback preserves every binding. */
+export declare function isContentVisibleFromScope(t: typeof Babel.types, path: Babel.NodePath<Babel.types.JSXElement>, component: TrackedComponentData, destinationScope: Babel.NodePath['scope']): boolean;
+/** Matches Datadog's click-time evaluation of content props and JSX children. */
+export declare function buildContentGetter(t: typeof Babel.types, path: Babel.NodePath<Babel.types.JSXElement>, component: TrackedComponentData, state: PluginState): Babel.types.ArrowFunctionExpression | null;

package/lib/typescript/actions/rum/index.d.ts

@@ -0,0 +1,4 @@
+import type * as Babel from '@babel/core';
+import type { NormalizedPluginOptions, PluginState } from '../../types';
+export declare function handleJSXElement(t: typeof Babel.types, path: Babel.NodePath<Babel.types.JSXElement>, state: PluginState, options: NormalizedPluginOptions): void;
+export declare function insertRuntimeImports(t: typeof Babel.types, programPath: Babel.NodePath<Babel.types.Program>, state: PluginState): void;

package/lib/typescript/actions/rum/memoization.d.ts

@@ -0,0 +1,4 @@
+import type * as Babel from '@babel/core';
+import type { ActionMetadata, PluginState, TrackedHandler } from '../../types';
+/** Wraps the hook callback once so JSX references retain their memoized identity. */
+export declare function wrapMemoizedHandler(t: typeof Babel.types, path: Babel.NodePath<Babel.types.JSXAttribute>, expression: Babel.types.Expression, metadata: ActionMetadata, state: PluginState, mode: TrackedHandler['mode'], actionType: TrackedHandler['actionType']): boolean;

package/lib/typescript/actions/rum/metadata.d.ts

@@ -0,0 +1,4 @@
+import type * as Babel from '@babel/core';
+import type { ActionMetadata, NormalizedPluginOptions, PluginState, TrackedComponentData } from '../../types';
+export declare function buildMetadata(t: typeof Babel.types, path: Babel.NodePath<Babel.types.JSXElement>, componentName: string, component: TrackedComponentData, options: NormalizedPluginOptions, state: PluginState): ActionMetadata;
+export declare function buildTargetObject(t: typeof Babel.types, metadata: ActionMetadata, handlerArgsIdentifier: Babel.types.Identifier, state: PluginState): Babel.types.ObjectExpression;

package/lib/typescript/actions/rum/tap.d.ts

@@ -0,0 +1,6 @@
+import type * as Babel from '@babel/core';
+import type { ActionMetadata, PluginState, TrackedHandler } from '../../types';
+/** Wraps a handler, or a handler factory when delayed mode is configured. */
+export declare function buildHandlerWrapper(t: typeof Babel.types, originalExpression: Babel.types.Expression, metadata: ActionMetadata, state: PluginState, scope: Babel.NodePath['scope'], mode?: TrackedHandler['mode'], actionType?: TrackedHandler['actionType']): Babel.types.ArrowFunctionExpression;
+/** Resolves a conditional handler once at render time, preserving non-functions. */
+export declare function buildGuardedHandlerWrapper(t: typeof Babel.types, originalExpression: Babel.types.Expression, metadata: ActionMetadata, state: PluginState, scope: Babel.NodePath['scope'], mode?: TrackedHandler['mode'], actionType?: TrackedHandler['actionType']): Babel.types.CallExpression;

package/lib/typescript/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const RUNTIME_PACKAGE = "@truewatchtech/react-native-mobile";
+export declare const ACTION_NAME_ATTRIBUTE = "ft-action-name";
+export declare const PLUGIN_ENABLED_FLAG = "__FT_RN_BABEL_PLUGIN_ENABLED__";
+export declare const NATIVE_COMPONENT_HANDLERS: Record<string, string[]>;

package/lib/typescript/index.d.ts

@@ -0,0 +1,5 @@
+import type * as Babel from '@babel/core';
+import type { PluginOptions, PluginState } from './types';
+export type { PluginOptions, TrackedComponent, TrackedHandler } from './types';
+declare const plugin: (api: typeof Babel & Babel.ConfigAPI, options: PluginOptions, dirname: string) => Babel.PluginObj<PluginState>;
+export default plugin;

package/lib/typescript/options.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedPluginOptions, PluginOptions } from './types';
+export declare function mergeOptions(options?: PluginOptions): NormalizedPluginOptions;

package/lib/typescript/state.d.ts

@@ -0,0 +1,5 @@
+import type * as Babel from '@babel/core';
+import type { NormalizedPluginOptions, PluginState } from './types';
+export declare function isSkippedFile(state: PluginState): boolean;
+/** Initializes per-file state; identifiers and memoization never leak across files. */
+export declare function initializePluginState(t: typeof Babel.types, programPath: Babel.NodePath<Babel.types.Program>, state: PluginState, options: NormalizedPluginOptions): void;

package/lib/typescript/types.d.ts

@@ -0,0 +1,56 @@
+import type * as Babel from '@babel/core';
+export type TrackedHandler = {
+    event: string;
+    actionType?: string;
+    mode?: 'default' | 'delayed';
+};
+export type TrackedComponent = {
+    name: string;
+    useContent?: boolean;
+    useNamePrefix?: boolean;
+    contentProp?: string;
+    handlers: TrackedHandler[];
+};
+export type PluginOptions = {
+    actionNameAttribute?: string;
+    components?: {
+        useContent?: boolean;
+        useNamePrefix?: boolean;
+        tracked?: TrackedComponent[];
+    };
+};
+export type NormalizedPluginOptions = {
+    actionNameAttribute?: string;
+    components: {
+        useContent: boolean;
+        useNamePrefix: boolean;
+        tracked: TrackedComponent[];
+    };
+};
+export type TrackedComponentData = Omit<TrackedComponent, 'name'> & {
+    importedName?: string;
+    isCustom: boolean;
+    useContent: boolean;
+    useNamePrefix: boolean;
+};
+export type ActionMetadata = {
+    accessibilityLabels: Babel.types.StringLiteral[];
+    actionNames: Babel.types.StringLiteral[];
+    component: TrackedComponentData;
+    componentName: string;
+    customActionNames: Babel.types.StringLiteral[];
+    getContent: Babel.types.ArrowFunctionExpression | null;
+};
+export type PluginState = Babel.PluginPass & {
+    _ftCustomNames: Set<string>;
+    _ftExtractTextIdentifier: Babel.types.Identifier;
+    _ftHasWrappedAction: boolean;
+    _ftMemoizedHandlers: Set<Babel.types.Node>;
+    _ftNeedsContentRuntime: boolean;
+    _ftReactIdentifier: Babel.types.Identifier;
+    _ftSkip: boolean;
+    _ftTrackedComponents: Record<string, TrackedComponentData>;
+    _ftTrackingIdentifier: Babel.types.Identifier;
+};
+export type PluginAPI = typeof Babel & Babel.ConfigAPI;
+export type JSXAttributePath = Babel.NodePath<Babel.types.JSXAttribute | Babel.types.JSXSpreadAttribute>;

package/lib/typescript/utils/jsx.d.ts

@@ -0,0 +1,4 @@
+import type * as Babel from '@babel/core';
+import type { JSXAttributePath } from '../types';
+export declare function getNodeName(t: typeof Babel.types, node: Babel.types.Node | null | undefined): string | null;
+export declare function getDirectAttributePaths(path: Babel.NodePath<Babel.types.JSXElement>): JSXAttributePath[];

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@truewatchtech/react-native-mobile-babel-plugin",
+  "version": "0.4.3-alpha.1",
+  "description": "Babel plugin for automatic TrueWatch React Native RUM action naming.",
+  "keywords": [
+    "babel",
+    "truewatch",
+    "react-native",
+    "rum"
+  ],
+  "main": "lib/commonjs/index",
+  "module": "lib/module/index",
+  "types": "lib/typescript/index.d.ts",
+  "source": "src/index",
+  "files": [
+    "src/**",
+    "lib",
+    "README.md"
+  ],
+  "scripts": {
+    "lint": "yarn run -T eslint \"src/**/*.{ts,tsx}\" \"test/**/*.js\"",
+    "prepare": "yarn run -T bob build",
+    "prepack": "yarn run -T check-version && yarn prepare",
+    "test": "yarn run -T jest",
+    "typescript": "yarn run -T tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TrueWatchTech/datakit-react-native.git"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0",
+    "@truewatchtech/react-native-mobile": "^0.4.3-0",
+    "react": ">=16.13.1",
+    "react-native": ">=0.63.4 <1.0"
+  },
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.20.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.20.0",
+    "@babel/plugin-transform-modules-commonjs": "^7.28.6",
+    "@babel/plugin-transform-react-jsx": "^7.25.2"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "tsc": "../../node_modules/.bin/tsc"
+        }
+      ]
+    ]
+  },
+  "jest": {
+    "testEnvironment": "node"
+  },
+  "gitHead": "41ab3e21571bff801c611771afd08e80b260de1b"
+}

package/src/actions/global.ts

@@ -0,0 +1,48 @@
+/*
+ * Portions of this file are adapted from Datadog's dd-sdk-reactnative Babel
+ * interaction tracking implementation, licensed under Apache-2.0.
+ */
+
+import type * as Babel from '@babel/core';
+import { PLUGIN_ENABLED_FLAG } from '../constants';
+
+export function insertPluginEnabledFlag(
+  t: typeof Babel.types,
+  programPath: Babel.NodePath<Babel.types.Program>
+): void {
+  const createFlagAssignment = (
+    globalIdentifier: Babel.types.Identifier
+  ): Babel.types.ExpressionStatement =>
+    t.expressionStatement(
+      t.assignmentExpression(
+        '=',
+        t.memberExpression(
+          t.cloneNode(globalIdentifier),
+          t.identifier(PLUGIN_ENABLED_FLAG)
+        ),
+        t.booleanLiteral(true)
+      )
+    );
+  const globalThisIdentifier = t.identifier('globalThis');
+  const reactNativeGlobalIdentifier = t.identifier('global');
+
+  programPath.unshiftContainer(
+    'body',
+    t.ifStatement(
+      t.binaryExpression(
+        '!==',
+        t.unaryExpression('typeof', t.cloneNode(globalThisIdentifier)),
+        t.stringLiteral('undefined')
+      ),
+      t.blockStatement([createFlagAssignment(globalThisIdentifier)]),
+      t.ifStatement(
+        t.binaryExpression(
+          '!==',
+          t.unaryExpression('typeof', t.cloneNode(reactNativeGlobalIdentifier)),
+          t.stringLiteral('undefined')
+        ),
+        t.blockStatement([createFlagAssignment(reactNativeGlobalIdentifier)])
+      )
+    )
+  );
+}

package/src/actions/rum/components.ts

@@ -0,0 +1,128 @@
+/*
+ * Portions of this file are adapted from Datadog's dd-sdk-reactnative Babel
+ * interaction tracking implementation, licensed under Apache-2.0.
+ */
+
+import type * as Babel from '@babel/core';
+import { NATIVE_COMPONENT_HANDLERS } from '../../constants';
+import type {
+  NormalizedPluginOptions,
+  TrackedComponentData,
+} from '../../types';
+import { getDirectAttributePaths, getNodeName } from '../../utils/jsx';
+
+export function createTrackedComponents(
+  t: typeof Babel.types,
+  programPath: Babel.NodePath<Babel.types.Program>,
+  options: NormalizedPluginOptions
+): Record<string, TrackedComponentData> {
+  const tracked: Record<string, TrackedComponentData> = {};
+
+  for (const statement of programPath.node.body) {
+    if (
+      !t.isImportDeclaration(statement) ||
+      statement.source.value !== 'react-native'
+    ) {
+      continue;
+    }
+
+    for (const specifier of statement.specifiers) {
+      if (!t.isImportSpecifier(specifier)) {
+        continue;
+      }
+      const importedName = getNodeName(t, specifier.imported);
+      const localName = getNodeName(t, specifier.local);
+      const events = importedName
+        ? NATIVE_COMPONENT_HANDLERS[importedName]
+        : undefined;
+      if (!events || !importedName || !localName) {
+        continue;
+      }
+      tracked[localName] = {
+        handlers: events.map((event) => ({ event })),
+        importedName,
+        isCustom: false,
+        useContent: options.components.useContent,
+        useNamePrefix: options.components.useNamePrefix,
+      };
+    }
+  }
+
+  for (const component of options.components.tracked) {
+    tracked[component.name] = {
+      ...(component.contentProp ? { contentProp: component.contentProp } : {}),
+      handlers: component.handlers || [],
+      isCustom: true,
+      useContent:
+        component.useContent === undefined
+          ? options.components.useContent
+          : component.useContent,
+      useNamePrefix:
+        component.useNamePrefix === undefined
+          ? options.components.useNamePrefix
+          : component.useNamePrefix,
+    };
+  }
+
+  return tracked;
+}
+
+export function isInsideConfiguredComponent(
+  t: typeof Babel.types,
+  path: Babel.NodePath<Babel.types.JSXElement>,
+  customComponentNames: Set<string>
+): boolean {
+  let current: Babel.NodePath | null = path.parentPath;
+  while (current && !current.isProgram()) {
+    if (
+      current.isFunctionDeclaration() ||
+      current.isClassDeclaration() ||
+      current.isVariableDeclarator()
+    ) {
+      const name = getNodeName(t, current.node.id);
+      if (name && customComponentNames.has(name)) {
+        return true;
+      }
+    }
+    current = current.parentPath;
+  }
+  return false;
+}
+
+export function addRequiredTextInputHandler(
+  t: typeof Babel.types,
+  path: Babel.NodePath<Babel.types.JSXElement>,
+  component: TrackedComponentData,
+  componentName: string
+): void {
+  if (
+    component.isCustom ||
+    component.importedName !== 'TextInput' ||
+    componentName !== 'TextInput'
+  ) {
+    return;
+  }
+  const attributes = getDirectAttributePaths(path);
+  const hasSpread = attributes.some((attribute) =>
+    attribute.isJSXSpreadAttribute()
+  );
+  const hasOnFocus = attributes.some(
+    (attribute) =>
+      attribute.isJSXAttribute() &&
+      getNodeName(t, attribute.node.name) === 'onFocus'
+  );
+  if (!hasSpread && !hasOnFocus) {
+    const openingElementPath = path.get(
+      'openingElement'
+    ) as Babel.NodePath<Babel.types.JSXOpeningElement>;
+    openingElementPath.pushContainer(
+      'attributes',
+      t.jsxAttribute(
+        t.jsxIdentifier('onFocus'),
+        t.jsxExpressionContainer(
+          t.arrowFunctionExpression([], t.blockStatement([]))
+        )
+      )
+    );
+  }
+}