react-native-mcp-kit 4.2.0 → 4.2.1

package/dist/babel/testIdPlugin/collectHooks.d.ts

@@ -0,0 +1,13 @@
+import { type NodePath, type types as BabelTypes } from '@babel/core';
+import { type CollectedHook } from './types';
+/**
+ * Walk a function body collecting hook-call metadata in source order. Names
+ * come from the consuming binding:
+ *   const [count, setCount] = useState(0)   → "count"
+ *   const memoValue         = useMemo(...)  → "memoValue"
+ *   useEffect(...)                          → "effect:<index>"
+ * The `kind` is taken from HOOK_KIND for built-ins, or "Custom" for any
+ * other identifier matching `/^use[A-Z]/`.
+ */
+export declare const collectHooksInBody: (body: NodePath<BabelTypes.Node>, t: typeof BabelTypes, shortFile: string, separator: string) => CollectedHook[];
+//# sourceMappingURL=collectHooks.d.ts.map

package/dist/babel/testIdPlugin/collectHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectHooks.d.ts","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/collectHooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAGtE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,SACvB,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,KAC5B,OAAO,UAAU,aACT,MAAM,aACN,MAAM,KAChB,aAAa,EAmGf,CAAC"}

package/dist/babel/testIdPlugin/collectHooks.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectHooksInBody = void 0;
+const constants_1 = require("./constants");
+/**
+ * Walk a function body collecting hook-call metadata in source order. Names
+ * come from the consuming binding:
+ *   const [count, setCount] = useState(0)   → "count"
+ *   const memoValue         = useMemo(...)  → "memoValue"
+ *   useEffect(...)                          → "effect:<index>"
+ * The `kind` is taken from HOOK_KIND for built-ins, or "Custom" for any
+ * other identifier matching `/^use[A-Z]/`.
+ */
+const collectHooksInBody = (body, t, shortFile, separator) => {
+    const hooks = [];
+    const anonCounters = {};
+    body.traverse({
+        CallExpression(callPath) {
+            const callee = callPath.node.callee;
+            // Three call shapes:
+            //   useState(x)           — direct identifier
+            //   React.useState(x)     — MemberExpression (compiled react libs)
+            //   _React2.useState(x)   — MemberExpression (bundler-mangled)
+            let hookIdent;
+            let isMemberCall = false;
+            let memberObject;
+            if (t.isIdentifier(callee)) {
+                hookIdent = callee.name;
+            }
+            else if (t.isMemberExpression(callee) &&
+                !callee.computed &&
+                t.isIdentifier(callee.property)) {
+                hookIdent = callee.property.name;
+                isMemberCall = true;
+                if (t.isIdentifier(callee.object))
+                    memberObject = callee.object.name;
+            }
+            if (!hookIdent || !constants_1.HOOK_NAME_RE.test(hookIdent))
+                return;
+            // For the `<obj>.use(...)` form, only accept calls with a React-like
+            // namespace as the object — otherwise `database.use(middleware)` and
+            // friends light up. `useXxx` member calls (`React.useState`) keep
+            // working through the same gate since their property name is unique
+            // enough on its own; the filter just prunes ambiguous bare `use`.
+            if (isMemberCall && hookIdent === 'use' && !constants_1.REACT_NAMESPACE_RE.test(memberObject ?? '')) {
+                return;
+            }
+            const kind = constants_1.HOOK_KIND[hookIdent] ?? 'Custom';
+            // Resolve hook name from the consuming binding when possible.
+            let hookName;
+            const parent = callPath.parent;
+            if (t.isVariableDeclarator(parent)) {
+                const id = parent.id;
+                if (t.isIdentifier(id)) {
+                    hookName = id.name;
+                }
+                else if (t.isArrayPattern(id)) {
+                    // const [value, setter] = useState(0)  → pick the first binding
+                    const first = id.elements[0];
+                    if (first && t.isIdentifier(first)) {
+                        hookName = first.name;
+                    }
+                }
+                else if (t.isObjectPattern(id)) {
+                    // const { foo } = useCustomHook() — rare, name it after the first key
+                    const firstProp = id.properties[0];
+                    if (firstProp && t.isObjectProperty(firstProp) && t.isIdentifier(firstProp.key)) {
+                        hookName = firstProp.key.name;
+                    }
+                }
+            }
+            if (!hookName) {
+                // Naked hook call (typical for useEffect). Generate a positional name
+                // keyed by the hook kind so "effect:0" / "effect:1" don't collide
+                // with state hooks if user has multiple effects.
+                const counterKey = kind.toLowerCase();
+                const index = anonCounters[counterKey] ?? 0;
+                anonCounters[counterKey] = index + 1;
+                hookName = `${counterKey}:${index}`;
+            }
+            const entry = { hook: hookIdent, kind, name: hookName };
+            const line = callPath.node.loc?.start.line;
+            if (line) {
+                entry.mcpId = `${hookName}${separator}${shortFile}${separator}${line}`;
+            }
+            if (kind === 'Custom' && !isMemberCall) {
+                // Only attach a function reference for direct-identifier calls where
+                // we can verify the binding is module-scoped (import / top-level
+                // const/let/var/function). MemberExpression calls (React.useX) are
+                // always built-in hooks anyway — kind ends up mapped, no expansion
+                // needed. Local/parameter names would throw ReferenceError at the
+                // injection site (which is module-level).
+                const binding = callPath.scope.getBinding(hookIdent);
+                if (binding && binding.scope.block.type === 'Program') {
+                    entry.fnIdent = hookIdent;
+                }
+            }
+            hooks.push(entry);
+        },
+        Function(innerPath) {
+            // Don't descend into nested functions — their hooks are not this
+            // component's hooks. `useCallback(() => {...})` is still traversed
+            // because the wrapper call is a call expression visited before we
+            // skip into the body (we only skip the nested function's own
+            // declaration/body traversal).
+            innerPath.skip();
+        },
+    });
+    return hooks;
+};
+exports.collectHooksInBody = collectHooksInBody;
+//# sourceMappingURL=collectHooks.js.map

package/dist/babel/testIdPlugin/collectHooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectHooks.js","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/collectHooks.ts"],"names":[],"mappings":"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"}

package/dist/babel/testIdPlugin/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_ATTR = "data-mcp-id";
+export declare const DEFAULT_EXCLUDE: string[];
+export declare const HOOK_KIND: Record<string, string>;
+export declare const HOOK_NAME_RE: RegExp;
+export declare const REACT_NAMESPACE_RE: RegExp;
+//# sourceMappingURL=constants.d.ts.map

package/dist/babel/testIdPlugin/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,gBAAgB,CAAC;AAE1C,eAAO,MAAM,eAAe,UAO3B,CAAC;AAQF,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAmB5C,CAAC;AAIF,eAAO,MAAM,YAAY,QAAkB,CAAC;AAQ5C,eAAO,MAAM,kBAAkB,QAAoB,CAAC"}

package/dist/babel/testIdPlugin/constants.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REACT_NAMESPACE_RE = exports.HOOK_NAME_RE = exports.HOOK_KIND = exports.DEFAULT_EXCLUDE = exports.DEFAULT_ATTR = void 0;
+exports.DEFAULT_ATTR = 'data-mcp-id';
+exports.DEFAULT_EXCLUDE = [
+    'Fragment',
+    'React.Fragment',
+    'React.StrictMode',
+    'React.Suspense',
+    'StrictMode',
+    'Suspense',
+];
+// Map of built-in React hook names → agent-friendly `kind` labels. Anything
+// matching the hook-name detector (`use` exact or `/^use[A-Z]/`) that is
+// NOT in this table is treated as "Custom".
+//
+// react-dom-only hooks (`useFormStatus`, `useFormState`) are intentionally
+// omitted — this library targets React Native, where neither exists.
+exports.HOOK_KIND = {
+    use: 'Use',
+    useActionState: 'ActionState',
+    useCallback: 'Callback',
+    useContext: 'Context',
+    useDebugValue: 'DebugValue',
+    useDeferredValue: 'DeferredValue',
+    useEffect: 'Effect',
+    useId: 'Id',
+    useImperativeHandle: 'ImperativeHandle',
+    useInsertionEffect: 'InsertionEffect',
+    useLayoutEffect: 'LayoutEffect',
+    useMemo: 'Memo',
+    useOptimistic: 'Optimistic',
+    useReducer: 'Reducer',
+    useRef: 'Ref',
+    useState: 'State',
+    useSyncExternalStore: 'SyncExternalStore',
+    useTransition: 'Transition',
+};
+// Hook-name detector. Accepts `use` exact (React 19's `use(promise|context)`)
+// AND the classic `use[A-Z]\w*` pattern.
+exports.HOOK_NAME_RE = /^use([A-Z]|$)/;
+// For the MemberExpression form (`X.use(...)`) we need to filter out
+// unrelated method calls — `database.use(middleware)`, `app.use(router)` etc.
+// Allow only object names that look like React-namespace bindings: literal
+// `React` / `react` and the common bundler-mangled forms (`_react`,
+// `_React2`, `_react3`, …). Same heuristic for any hook, but matters most
+// for bare `use` whose name is otherwise too generic to disambiguate.
+exports.REACT_NAMESPACE_RE = /^_?[Rr]eact\d*$/;
+//# sourceMappingURL=constants.js.map

package/dist/babel/testIdPlugin/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,YAAY,GAAG,aAAa,CAAC;AAE7B,QAAA,eAAe,GAAG;IAC7B,UAAU;IACV,gBAAgB;IAChB,kBAAkB;IAClB,gBAAgB;IAChB,YAAY;IACZ,UAAU;CACX,CAAC;AAEF,4EAA4E;AAC5E,yEAAyE;AACzE,4CAA4C;AAC5C,EAAE;AACF,2EAA2E;AAC3E,qEAAqE;AACxD,QAAA,SAAS,GAA2B;IAC/C,GAAG,EAAE,KAAK;IACV,cAAc,EAAE,aAAa;IAC7B,WAAW,EAAE,UAAU;IACvB,UAAU,EAAE,SAAS;IACrB,aAAa,EAAE,YAAY;IAC3B,gBAAgB,EAAE,eAAe;IACjC,SAAS,EAAE,QAAQ;IACnB,KAAK,EAAE,IAAI;IACX,mBAAmB,EAAE,kBAAkB;IACvC,kBAAkB,EAAE,iBAAiB;IACrC,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,MAAM;IACf,aAAa,EAAE,YAAY;IAC3B,UAAU,EAAE,SAAS;IACrB,MAAM,EAAE,KAAK;IACb,QAAQ,EAAE,OAAO;IACjB,oBAAoB,EAAE,mBAAmB;IACzC,aAAa,EAAE,YAAY;CAC5B,CAAC;AAEF,8EAA8E;AAC9E,yCAAyC;AAC5B,QAAA,YAAY,GAAG,eAAe,CAAC;AAE5C,qEAAqE;AACrE,8EAA8E;AAC9E,2EAA2E;AAC3E,oEAAoE;AACpE,0EAA0E;AAC1E,sEAAsE;AACzD,QAAA,kBAAkB,GAAG,iBAAiB,CAAC"}

package/dist/babel/testIdPlugin/helpers.d.ts

@@ -0,0 +1,7 @@
+import { type NodePath, type types as BabelTypes } from '@babel/core';
+export declare const isCapitalized: (name: string | undefined) => boolean;
+export declare const getShortFile: (filename: string | null | undefined) => string;
+export declare const isCustomHookName: (name: string | undefined) => boolean;
+export declare const bodyUsesJSX: (bodyPath: NodePath<BabelTypes.Node>) => boolean;
+export declare const bodyCallsHook: (bodyPath: NodePath<BabelTypes.Node>, t: typeof BabelTypes) => boolean;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/babel/testIdPlugin/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAQtE,eAAO,MAAM,aAAa,SAAU,MAAM,GAAG,SAAS,KAAG,OAOxD,CAAC;AAMF,eAAO,MAAM,YAAY,aAAc,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,MAMlE,CAAC;AAMF,eAAO,MAAM,gBAAgB,SAAU,MAAM,GAAG,SAAS,KAAG,OAE3D,CAAC;AAIF,eAAO,MAAM,WAAW,aAAc,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,KAAG,OAWjE,CAAC;AAEF,eAAO,MAAM,aAAa,aACd,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,KAChC,OAAO,UAAU,KACnB,OAwBF,CAAC"}

package/dist/babel/testIdPlugin/helpers.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyCallsHook = exports.bodyUsesJSX = exports.isCustomHookName = exports.getShortFile = exports.isCapitalized = void 0;
+// Cheap, conservative component detector: the binding name starts with a
+// capital letter and the function body mentions JSX somewhere. Covers
+// `function LoginForm() { return <View />; }` and
+// `const LoginForm = (props) => <View />;`. HOC-wrapped components
+// (memo / forwardRef / observer) are handled in `VariableDeclarator` by
+// unwrapping the call expression first via `findInnerFunctionBodyPath`.
+const isCapitalized = (name) => {
+    return (!!name &&
+        name.length > 0 &&
+        name[0] === name[0]?.toUpperCase() &&
+        name[0] !== name[0]?.toLowerCase());
+};
+exports.isCapitalized = isCapitalized;
+// Strip the absolute path prefix (anything up to and including the project's
+// `/src/`) and drop the .ts/.tsx/.js/.jsx extension. Same shape components
+// use inside `data-mcp-id` so a hook's `mcpId` and a JSX element's
+// `data-mcp-id` look interchangeable to an agent reading them.
+const getShortFile = (filename) => {
+    const file = filename ?? 'unknown';
+    const relative = file.includes('/src/')
+        ? (file.split('/src/').pop() ?? file)
+        : (file.split('/').pop() ?? file);
+    return relative.replace(/\.(tsx?|jsx?)$/, '');
+};
+exports.getShortFile = getShortFile;
+// Is this a candidate custom hook definition? Name matches `use[A-Z]...`
+// and the body contains at least one built-in or custom hook call. Matches
+// userland hooks AND library hook sources that happen to pass through our
+// babel transform (Metro runs plugins on node_modules by default).
+const isCustomHookName = (name) => {
+    return !!name && /^use[A-Z]/.test(name);
+};
+exports.isCustomHookName = isCustomHookName;
+// Heuristic: the function body must reference JSX. Otherwise it's just a
+// plain capitalized helper that happens to share the naming convention.
+const bodyUsesJSX = (bodyPath) => {
+    let uses = false;
+    bodyPath.traverse({
+        JSXElement() {
+            uses = true;
+        },
+        JSXFragment() {
+            uses = true;
+        },
+    });
+    return uses;
+};
+exports.bodyUsesJSX = bodyUsesJSX;
+const bodyCallsHook = (bodyPath, t) => {
+    let hit = false;
+    bodyPath.traverse({
+        CallExpression(callPath) {
+            if (hit)
+                return;
+            const callee = callPath.node.callee;
+            if (t.isIdentifier(callee) && /^use[A-Z]/.test(callee.name)) {
+                hit = true;
+                return;
+            }
+            if (t.isMemberExpression(callee) &&
+                !callee.computed &&
+                t.isIdentifier(callee.property) &&
+                /^use[A-Z]/.test(callee.property.name)) {
+                hit = true;
+            }
+        },
+        Function(innerPath) {
+            innerPath.skip();
+        },
+    });
+    return hit;
+};
+exports.bodyCallsHook = bodyCallsHook;
+//# sourceMappingURL=helpers.js.map

package/dist/babel/testIdPlugin/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/helpers.ts"],"names":[],"mappings":"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"}

package/dist/babel/testIdPlugin/hocUnwrap.d.ts

@@ -0,0 +1,4 @@
+import { type NodePath, type types as BabelTypes } from '@babel/core';
+export declare const findInnerFunctionBodyPath: (startPath: NodePath<BabelTypes.Node>, t: typeof BabelTypes) => NodePath<BabelTypes.Node> | null;
+export declare const findInnerIdentifier: (startPath: NodePath<BabelTypes.Node>, t: typeof BabelTypes) => NodePath<BabelTypes.Identifier> | null;
+//# sourceMappingURL=hocUnwrap.d.ts.map

package/dist/babel/testIdPlugin/hocUnwrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hocUnwrap.d.ts","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/hocUnwrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAmFtE,eAAO,MAAM,yBAAyB,cACzB,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,KACjC,OAAO,UAAU,KACnB,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,IAO9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,cACnB,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,KACjC,OAAO,UAAU,KACnB,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,IAIpC,CAAC"}

package/dist/babel/testIdPlugin/hocUnwrap.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findInnerIdentifier = exports.findInnerFunctionBodyPath = void 0;
+// Recognize callee shapes that look like an HOC application without locking
+// to a hardcoded name list. Two shapes pass:
+//   1. `memo(fn)` / `forwardRef(fn)` / `withAuth(fn)` — bare Identifier callee.
+//   2. `React.memo(fn)` / `Mobx.observer(fn)` — MemberExpression where the
+//      object identifier resolves to a module (import) binding. This rules
+//      out `arr.map(fn)` and similar local-method calls, which would
+//      otherwise produce harmless-but-noisy metadata on a non-component
+//      binding. Property access on a deep chain (`a.b.c(fn)`) is rejected.
+const isLikelyHocCallee = (callPath, t) => {
+    const callee = callPath.node.callee;
+    if (t.isIdentifier(callee))
+        return true;
+    if (t.isMemberExpression(callee) &&
+        !callee.computed &&
+        t.isIdentifier(callee.property) &&
+        t.isIdentifier(callee.object)) {
+        const binding = callPath.scope.getBinding(callee.object.name);
+        return !!binding && binding.kind === 'module';
+    }
+    return false;
+};
+// Walk down a CallExpression chain (`memo(forwardRef(...))`,
+// `withAuth(observer(...))`, etc.) to whatever the chain bottoms out at.
+// Returns null if no unwrap happened (the start was not a recognized HOC
+// chain). Each link must look like a plausible HOC application via
+// `isLikelyHocCallee`, so non-HOC calls that happen to take a function
+// argument (e.g. `arr.map(fn)`) don't trigger metadata attachment on the
+// outer binding.
+//
+// Transparently steps through `AssignmentExpression` and `SequenceExpression`
+// wrappers — react-refresh injects `_c = <fn>` and similar synthetic
+// expression wraps around the inner component during its `VariableDeclaration`
+// enter visitor (which runs before our `VariableDeclarator` visitor). Without
+// the step-through, our unwrap would dead-end at the AssignmentExpression
+// and miss the inner arrow / function expression entirely.
+const unwrapTransparentExpr = (path) => {
+    let cur = path;
+    // Bound the loop to defend against pathological ASTs.
+    for (let i = 0; i < 8; i++) {
+        if (cur.isAssignmentExpression() && cur.node.operator === '=') {
+            cur = cur.get('right');
+            continue;
+        }
+        if (cur.isSequenceExpression()) {
+            const exprs = cur.get('expressions');
+            if (exprs.length === 0)
+                break;
+            cur = exprs[exprs.length - 1];
+            continue;
+        }
+        break;
+    }
+    return cur;
+};
+const unwrapHocChainToBottom = (startPath, t) => {
+    let cur = unwrapTransparentExpr(startPath);
+    let unwrapped = false;
+    while (cur.isCallExpression() && cur.node.arguments.length > 0 && isLikelyHocCallee(cur, t)) {
+        const arg0 = cur.get('arguments.0');
+        if (!arg0.node)
+            return null;
+        cur = unwrapTransparentExpr(arg0);
+        unwrapped = true;
+    }
+    return unwrapped ? cur : null;
+};
+// Two consumers of the unwrap walk:
+//   1. Inline-function case (`memo(() => <JSX />)`) — find the body so we can
+//      collect hooks and attach metadata directly to the outer binding.
+//   2. Identifier-ref case (`memo(InnerFn)`) — record `{ outer, inner }` so a
+//      deferred copy `Outer.__mcp_hooks = Inner.__mcp_hooks` can be emitted
+//      at Program:exit. The inline case can't use the deferred copy approach
+//      because there's no name to copy from.
+const findInnerFunctionBodyPath = (startPath, t) => {
+    const bottom = unwrapHocChainToBottom(startPath, t);
+    if (!bottom)
+        return null;
+    if (bottom.isArrowFunctionExpression() || bottom.isFunctionExpression()) {
+        return bottom.get('body');
+    }
+    return null;
+};
+exports.findInnerFunctionBodyPath = findInnerFunctionBodyPath;
+const findInnerIdentifier = (startPath, t) => {
+    const bottom = unwrapHocChainToBottom(startPath, t);
+    if (!bottom)
+        return null;
+    return bottom.isIdentifier() ? bottom : null;
+};
+exports.findInnerIdentifier = findInnerIdentifier;
+//# sourceMappingURL=hocUnwrap.js.map

package/dist/babel/testIdPlugin/hocUnwrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hocUnwrap.js","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/hocUnwrap.ts"],"names":[],"mappings":";;;AAEA,4EAA4E;AAC5E,6CAA6C;AAC7C,gFAAgF;AAChF,2EAA2E;AAC3E,2EAA2E;AAC3E,qEAAqE;AACrE,wEAAwE;AACxE,2EAA2E;AAC3E,MAAM,iBAAiB,GAAG,CACxB,QAA6C,EAC7C,CAAoB,EACX,EAAE;IACX,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;IACpC,IAAI,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,IACE,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC;QAC5B,CAAC,MAAM,CAAC,QAAQ;QAChB,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC;QAC/B,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,EAC7B,CAAC;QACD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC9D,OAAO,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC;IAChD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF,6DAA6D;AAC7D,yEAAyE;AACzE,yEAAyE;AACzE,mEAAmE;AACnE,uEAAuE;AACvE,yEAAyE;AACzE,iBAAiB;AACjB,EAAE;AACF,8EAA8E;AAC9E,qEAAqE;AACrE,+EAA+E;AAC/E,8EAA8E;AAC9E,0EAA0E;AAC1E,2DAA2D;AAC3D,MAAM,qBAAqB,GAAG,CAAC,IAA+B,EAA6B,EAAE;IAC3F,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,sDAAsD;IACtD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,GAAG,CAAC,sBAAsB,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;YAC9D,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,CAA8B,CAAC;YACpD,SAAS;QACX,CAAC;QACD,IAAI,GAAG,CAAC,oBAAoB,EAAE,EAAE,CAAC;YAC/B,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,aAAa,CAAsC,CAAC;YAC1E,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,MAAM;YAC9B,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAA8B,CAAC;YAC3D,SAAS;QACX,CAAC;QACD,MAAM;IACR,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,CAC7B,SAAoC,EACpC,CAAoB,EACc,EAAE;IACpC,IAAI,GAAG,GAA8B,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACtE,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,OAAO,GAAG,CAAC,gBAAgB,EAAE,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;QAC5F,MAAM,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,aAAa,CAA8B,CAAC;QACjE,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QAC5B,GAAG,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;QAClC,SAAS,GAAG,IAAI,CAAC;IACnB,CAAC;IACD,OAAO,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AAChC,CAAC,CAAC;AAEF,oCAAoC;AACpC,8EAA8E;AAC9E,wEAAwE;AACxE,8EAA8E;AAC9E,4EAA4E;AAC5E,6EAA6E;AAC7E,6CAA6C;AACtC,MAAM,yBAAyB,GAAG,CACvC,SAAoC,EACpC,CAAoB,EACc,EAAE;IACpC,MAAM,MAAM,GAAG,sBAAsB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IACpD,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,IAAI,MAAM,CAAC,yBAAyB,EAAE,IAAI,MAAM,CAAC,oBAAoB,EAAE,EAAE,CAAC;QACxE,OAAO,MAAM,CAAC,GAAG,CAAC,MAAM,CAA8B,CAAC;IACzD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAVW,QAAA,yBAAyB,6BAUpC;AAEK,MAAM,mBAAmB,GAAG,CACjC,SAAoC,EACpC,CAAoB,EACoB,EAAE;IAC1C,MAAM,MAAM,GAAG,sBAAsB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IACpD,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,OAAO,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAE,MAA0C,CAAC,CAAC,CAAC,IAAI,CAAC;AACpF,CAAC,CAAC;AAPW,QAAA,mBAAmB,uBAO9B"}

package/dist/babel/{testIdPlugin.d.ts → testIdPlugin/index.d.ts}

@@ -2,4 +2,4 @@ import { type PluginObj, type types as BabelTypes } from '@babel/core';
 export default function testIdPlugin({ types: t }: {
     types: typeof BabelTypes;
 }): PluginObj;
-//# sourceMappingURL=testIdPlugin.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/babel/testIdPlugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/babel/testIdPlugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,KAAK,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAoBtF,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,UAAU,CAAA;CAAE,GAAG,SAAS,CAgN1F"}

package/dist/babel/testIdPlugin/index.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = testIdPlugin;
+const collectHooks_1 = require("./collectHooks");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+const hocUnwrap_1 = require("./hocUnwrap");
+const inject_1 = require("./inject");
+function testIdPlugin({ types: t }) {
+    return {
+        name: 'react-native-mcp-test-id',
+        visitor: {
+            // === Part 2: attach __mcp_hooks metadata. ===
+            // Two candidate shapes per function declaration:
+            //   1. Component — capitalized name + JSX in body (React component).
+            //   2. Custom hook — name matches /^use[A-Z]/ + body contains hook calls.
+            // The VariableDeclarator visitor below covers the
+            // `const Foo = (...) => {...}` / `const useX = (...) => {...}` forms,
+            // plus HOC-wrapped components: `const Foo = anyHoc((props) => <JSX />)`
+            // and nested chains thereof.
+            FunctionDeclaration(path, state) {
+                const id = path.node.id;
+                if (!id)
+                    return;
+                const bodyPath = path.get('body');
+                const pluginState = state;
+                const opts = (state.opts ?? {});
+                const separator = opts.separator ?? ':';
+                const shortFile = (0, helpers_1.getShortFile)(state.filename);
+                // Component: capitalized name + (JSX in body OR hook calls in body).
+                // The hook-call branch covers components that legitimately return
+                // null / non-JSX values — portal-like, context-only, or
+                // imperative-handle wrappers. Under the Rules of Hooks, only
+                // components and custom hooks may call hooks, so a capitalized
+                // function that calls them is unambiguously a component.
+                if ((0, helpers_1.isCapitalized)(id.name) && ((0, helpers_1.bodyUsesJSX)(bodyPath) || (0, helpers_1.bodyCallsHook)(bodyPath, t))) {
+                    const hooks = (0, collectHooks_1.collectHooksInBody)(bodyPath, t, shortFile, separator);
+                    (0, inject_1.queueHooksAssignment)(pluginState, path, id.name, hooks);
+                    return;
+                }
+                // Custom hook: name matches use[A-Z] + body calls at least one hook.
+                if ((0, helpers_1.isCustomHookName)(id.name) && (0, helpers_1.bodyCallsHook)(bodyPath, t)) {
+                    const hooks = (0, collectHooks_1.collectHooksInBody)(bodyPath, t, shortFile, separator);
+                    (0, inject_1.queueHooksAssignment)(pluginState, path, id.name, hooks);
+                }
+            },
+            // === Part 1: stamp data-mcp-id on capitalized JSX elements. ===
+            JSXOpeningElement(path, state) {
+                const opts = (state.opts ?? {});
+                const attrName = opts.attr ?? constants_1.DEFAULT_ATTR;
+                const separator = opts.separator ?? ':';
+                const exclude = opts.exclude ?? constants_1.DEFAULT_EXCLUDE;
+                const include = opts.include;
+                const nameNode = path.node.name;
+                let componentName;
+                if (t.isJSXIdentifier(nameNode)) {
+                    componentName = nameNode.name;
+                }
+                else if (t.isJSXMemberExpression(nameNode)) {
+                    componentName = `${nameNode.object.name}.${nameNode.property.name}`;
+                }
+                else {
+                    return;
+                }
+                if (componentName[0] === componentName[0]?.toLowerCase())
+                    return;
+                if (include && !include.includes(componentName))
+                    return;
+                if (exclude.includes(componentName))
+                    return;
+                const shortFile = (0, helpers_1.getShortFile)(state.filename);
+                const line = path.node.loc?.start.line ?? 0;
+                const generatedId = `${componentName}${separator}${shortFile}${separator}${line}`;
+                const existingAttr = path.node.attributes.find((attr) => {
+                    return t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name, { name: attrName });
+                });
+                if (existingAttr && t.isJSXAttribute(existingAttr)) {
+                    if (t.isStringLiteral(existingAttr.value)) {
+                        const existing = existingAttr.value.value;
+                        existingAttr.value = t.stringLiteral(`${existing}${separator}${shortFile}${separator}${line}`);
+                    }
+                    return;
+                }
+                path.node.attributes.push(t.jsxAttribute(t.jsxIdentifier(attrName), t.stringLiteral(generatedId)));
+            },
+            // === Part 3: drain deferred-injection queue at module end. ===
+            // Runs after all other plugins' visitors (in particular react-refresh's
+            // replaceWith on HOC-wrapped components) have finished mutating the
+            // tree. We dedupe by `outer` name to defend against multiple visitor
+            // passes queuing the same component twice, then push every queued
+            // statement onto the END of the Program body. End-of-body is the only
+            // placement that's safe across react-compiler + worklets + unistyles:
+            // earlier plugins can rewrite a `const Foo = ...` declaration into a
+            // hoisted `var Foo = ...` and slip extracted helpers (`_worklet_..._init_data`,
+            // memoization scaffolding) BEFORE Foo's source line, leaving an
+            // insertAfter-target-position holding a stale `undefined` binding.
+            Program: {
+                exit(programPath, state) {
+                    const pluginState = state;
+                    const queue = pluginState.pendingInjects;
+                    if (!queue || queue.length === 0)
+                        return;
+                    const seen = new Set();
+                    for (const entry of queue) {
+                        if (seen.has(entry.outer))
+                            continue;
+                        seen.add(entry.outer);
+                        if (entry.kind === 'assignment') {
+                            programPath.pushContainer('body', (0, inject_1.buildAssignmentStmt)(entry.outer, entry.hooks, t));
+                        }
+                        else {
+                            programPath.pushContainer('body', (0, inject_1.buildHooksGetterStmt)(entry.outer, entry.inner, t));
+                        }
+                    }
+                    pluginState.pendingInjects = [];
+                },
+            },
+            VariableDeclarator(path, state) {
+                const id = path.node.id;
+                if (!t.isIdentifier(id))
+                    return;
+                let initNode = path.node.init;
+                if (!initNode)
+                    return;
+                const pluginState = state;
+                // Unwrap TypeScript casts: `as Foo`, `as const`, `<Foo>x` (legacy
+                // angle-bracket assertion), and `x satisfies Foo`. Without this,
+                // `const Wrapped = memo(arrow) as { ... }` fails our HOC unwrap
+                // because we'd see TSAsExpression instead of the inner CallExpression.
+                // Pattern in the wild: 21vek's PageFlashListWithBanner /
+                // ListProductRow / RangeFilter use `as` to attach generic call
+                // signatures + displayName onto memo'd components.
+                let initPathForUnwrap = path.get('init');
+                for (let i = 0; i < 4; i++) {
+                    if (t.isTSAsExpression(initNode) ||
+                        t.isTSTypeAssertion(initNode) ||
+                        t.isTSSatisfiesExpression(initNode) ||
+                        t.isTSNonNullExpression(initNode)) {
+                        initPathForUnwrap = initPathForUnwrap.get('expression');
+                        initNode = initPathForUnwrap.node;
+                        continue;
+                    }
+                    break;
+                }
+                const init = initNode;
+                // Resolve the function body to inspect. Three shapes:
+                //   const Foo = (props) => <JSX />              — direct arrow / fn
+                //   const Foo = memo((props) => <JSX />)        — single-HOC wrap
+                //   const Foo = memo(forwardRef((p, r) => ...)) — nested HOC chain
+                // For HOC wrappers, attaching `Foo.__mcp_hooks = [...]` on the outer
+                // binding works because `memo()` / `forwardRef()` return plain JS
+                // objects that React stores in `fiber.type` — the runtime read path
+                // is identical to the bare-component case. The unwrap is name-
+                // agnostic (any Identifier or import-namespaced MemberExpression
+                // callee qualifies), so custom HOCs like `withAuth(...)` work too.
+                let bodyPath = null;
+                if (t.isArrowFunctionExpression(init) || t.isFunctionExpression(init)) {
+                    bodyPath = initPathForUnwrap.get('body');
+                }
+                else if (t.isCallExpression(init)) {
+                    bodyPath = (0, hocUnwrap_1.findInnerFunctionBodyPath)(initPathForUnwrap, t);
+                    // Identifier-ref HOC case: `const Foo = memo(InnerFn)`. The inner
+                    // arg is a name, not an inline function — so we can't statically
+                    // collect hooks here. Instead, install a getter on `Foo` that
+                    // forwards to `Inner.__mcp_hooks` at read time.
+                    if (!bodyPath && (0, helpers_1.isCapitalized)(id.name)) {
+                        const inner = (0, hocUnwrap_1.findInnerIdentifier)(initPathForUnwrap, t);
+                        if (inner && inner.scope.getBinding(inner.node.name)) {
+                            const stmt = path.getStatementParent();
+                            if (stmt) {
+                                (0, inject_1.queueHooksGetter)(pluginState, stmt, id.name, inner.node.name);
+                            }
+                        }
+                    }
+                }
+                if (!bodyPath || !bodyPath.node)
+                    return;
+                const opts = (state.opts ?? {});
+                const separator = opts.separator ?? ':';
+                const shortFile = (0, helpers_1.getShortFile)(state.filename);
+                // Component: capitalized + (JSX in body OR hook calls). Same
+                // rationale as FunctionDeclaration above — Rules of Hooks pin a
+                // capitalized hook-calling function to "component", so JSX is
+                // sufficient but not necessary (covers `return null` portals).
+                if ((0, helpers_1.isCapitalized)(id.name) && ((0, helpers_1.bodyUsesJSX)(bodyPath) || (0, helpers_1.bodyCallsHook)(bodyPath, t))) {
+                    const hooks = (0, collectHooks_1.collectHooksInBody)(bodyPath, t, shortFile, separator);
+                    const statement = path.getStatementParent();
+                    if (!statement)
+                        return;
+                    (0, inject_1.queueHooksAssignment)(pluginState, statement, id.name, hooks);
+                    return;
+                }
+                // Custom hook: use[A-Z] + body calls hooks.
+                if ((0, helpers_1.isCustomHookName)(id.name) && (0, helpers_1.bodyCallsHook)(bodyPath, t)) {
+                    const hooks = (0, collectHooks_1.collectHooksInBody)(bodyPath, t, shortFile, separator);
+                    const statement = path.getStatementParent();
+                    if (!statement)
+                        return;
+                    (0, inject_1.queueHooksAssignment)(pluginState, statement, id.name, hooks);
+                }
+            },
+        },
+    };
+}
+//# sourceMappingURL=index.js.map