react-native-mcp-kit 2.1.0 → 2.2.0

package/dist/modules/fiberTree/fiberTree.js

@@ -3,24 +3,163 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fiberTreeModule = void 0;
 const utils_1 = require("./utils");
 const DEFAULT_DEPTH = 10;
+const QUERY_LIMIT_DEFAULT = 50;
+const QUERY_LIMIT_MAX = 500;
+const QUERY_DEFAULT_FIELDS = ['mcpId', 'name', 'testID'];
 const FIND_SCHEMA = {
     index: {
-        description: 'Zero-based index when multiple components match (default: 0, i.e. first match)',
+        description: '0-based index when several components match (default: 0).',
         type: 'number',
     },
-    mcpId: { description: 'data-mcp-id to search for', type: 'string' },
-    name: { description: 'Component name to search for', type: 'string' },
-    testID: { description: 'testID to search for', type: 'string' },
-    text: { description: 'Text content to search for', type: 'string' },
+    mcpId: { description: 'Stable data-mcp-id to match.', type: 'string' },
+    name: { description: 'Component name to match.', type: 'string' },
+    testID: { description: 'testID to match.', type: 'string' },
+    text: { description: 'Rendered text substring (not prop values).', type: 'string' },
     within: {
-        description: 'Search within a parent component path. Use "/" for nesting, ":N" for index. E.g. "Checkbox/Pressable", "Button:1/View"',
+        description: 'Parent component path. "/" nests, ":N" picks index.',
+        examples: ['LoginForm', 'Button:1/Pressable', 'TabBar/TabBarItem:2'],
         type: 'string',
     },
 };
+const resolveScreenFiber = (runtime) => {
+    const nav = runtime.navigationRef;
+    if (!nav || typeof nav.getCurrentRoute !== 'function')
+        return null;
+    const route = nav.getCurrentRoute();
+    const key = route && typeof route.key === 'string' ? route.key : undefined;
+    if (!key)
+        return null;
+    return (0, utils_1.findScreenFiberByRouteKey)(runtime.root, key);
+};
+const collectByScope = (fiber, scope, runtime) => {
+    switch (scope) {
+        case 'self':
+            return [fiber];
+        case 'parent':
+            return fiber.return ? [fiber.return] : [];
+        case 'ancestors':
+            return (0, utils_1.getAncestors)(fiber);
+        case 'children':
+            return (0, utils_1.getDirectChildren)(fiber);
+        case 'siblings':
+            return (0, utils_1.getSiblings)(fiber);
+        case 'nearest_host': {
+            const host = (0, utils_1.findHostFiber)(fiber);
+            return host ? [host] : [];
+        }
+        case 'screen': {
+            const screen = resolveScreenFiber(runtime);
+            if (!screen)
+                return [];
+            return (0, utils_1.findAllByQuery)(screen, {}).filter((f) => {
+                return f !== screen;
+            });
+        }
+        case 'descendants':
+        default:
+            return (0, utils_1.findAllByQuery)(fiber, {}).filter((f) => {
+                return f !== fiber;
+            });
+    }
+};
+const runQueryChain = (runtime, steps) => {
+    let current = [runtime.root];
+    for (const step of steps) {
+        const scope = step.scope ?? 'descendants';
+        const seen = new Set();
+        const collected = [];
+        for (const fiber of current) {
+            for (const candidate of collectByScope(fiber, scope, runtime)) {
+                if (!seen.has(candidate)) {
+                    seen.add(candidate);
+                    collected.push(candidate);
+                }
+            }
+        }
+        const filtered = collected.filter((f) => {
+            return (0, utils_1.matchesQuery)(f, step);
+        });
+        if (typeof step.index === 'number') {
+            const picked = filtered[step.index];
+            current = picked ? [picked] : [];
+        }
+        else {
+            current = filtered;
+        }
+        if (current.length === 0)
+            return [];
+    }
+    return current;
+};
+// Keep only fibers whose ancestor chain contains no other match. Removes
+// wrapper cascades (PressableView → Pressable → View → RCTView) while keeping
+// independent siblings with overlapping bounds (e.g. absolute-positioned
+// overlays). Preserves original DFS order.
+const dedupAncestors = (matches) => {
+    if (matches.length < 2)
+        return matches;
+    const matchSet = new Set(matches);
+    return matches.filter((fiber) => {
+        let p = fiber.return;
+        while (p) {
+            if (matchSet.has(p))
+                return false;
+            p = p.return;
+        }
+        return true;
+    });
+};
+// Window dimensions → physical-pixel bounds rectangle for `onlyVisible` filter.
+const getVisibleRect = () => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+        const RN = require('react-native');
+        const { Dimensions, PixelRatio } = RN;
+        const window = Dimensions?.get?.('window');
+        const ratio = PixelRatio?.get?.() ?? 1;
+        if (!window || !Number.isFinite(window.width) || !Number.isFinite(window.height))
+            return null;
+        return {
+            height: window.height * ratio,
+            width: window.width * ratio,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const intersectsRect = (bounds, rect) => {
+    return (bounds.x + bounds.width > 0 &&
+        bounds.y + bounds.height > 0 &&
+        bounds.x < rect.width &&
+        bounds.y < rect.height);
+};
 const fiberTreeModule = (options) => {
     if (options?.rootRef) {
         (0, utils_1.setRootRef)(options.rootRef);
     }
+    const navigationRef = options?.navigationRef;
+    // Root-version keyed cache for `runQueryChain`. When React commits, the
+    // HostRoot fiber swaps — so a mismatched pointer is proof the tree changed
+    // and the cached match set for the same steps is no longer valid.
+    // Enabled by default (cache: true); `cache: false` bypasses lookup + write.
+    let cacheRoot = null;
+    const cacheEntries = new Map();
+    const runCachedQuery = (runtime, steps, useCache) => {
+        if (!useCache)
+            return runQueryChain(runtime, steps);
+        if (cacheRoot !== runtime.root) {
+            cacheRoot = runtime.root;
+            cacheEntries.clear();
+        }
+        const key = JSON.stringify(steps);
+        const hit = cacheEntries.get(key);
+        if (hit)
+            return hit;
+        const result = runQueryChain(runtime, steps);
+        cacheEntries.set(key, result);
+        return result;
+    };
     const findInRoot = (root, segment) => {
         if (!root)
             return null;
@@ -78,44 +217,69 @@ const fiberTreeModule = (options) => {
         return null;
     };
     return {
-        description: `React component tree inspection and interaction.
+        description: `React fiber tree inspection and interaction.
 
-## Finding components
-- find_all with hasProps: ["onPress"] — find all pressable elements
-- find_all with hasProps: ["onChangeText"] — find all text inputs
-- find_all with name: "Button" — find by component name
-- get_component with mcpId: "Button:screens/Login:42" — find by stable ID
+SCOPES (query steps)
+  descendants (default) / children / parent / ancestors / siblings / self
+  / screen / nearest_host.
+    · screen — descendants of the currently focused React Navigation
+      screen fiber. Available when the library was initialized with a
+      navigationRef. Lets a first step skip "find current screen first".
+    · nearest_host — walks down to the first mounted HOST_COMPONENT
+      fiber. Useful before call_ref (focus/blur/measure) which require
+      a host instance.
 
-## Interacting
-- invoke with callback: "onPress" — press a button
-- invoke with callback: "onChangeText", args: ["text"] — type into input
-- invoke with callback: "onPress", args: [true] — toggle checkbox
-- call_ref with method: "focus" — focus an input
+STEP CRITERIA
+  name / mcpId / testID — strict equality.
+  text — substring match in RENDERED text only (not prop values).
+  hasProps — array of prop names that must exist.
+  props — map of prop → matcher:
+    · primitive → strict equality.
+    · { contains: "X" } / { regex: "Y" } → match via String(value); primitives only by default.
+    · add deep: true → also JSON-serialize objects/arrays and match inside.
+  any — array of sub-criteria; OR semantics.
+    Example: { any: [{ name: "Pressable" }, { name: "TouchableOpacity" }] }.
+  not — nested criteria; excludes fibers that match the inner query.
+    Composes with the others: { hasProps: ["onPress"], not: { testID: "loading" } }.
+    Accepts an array for multi-pattern exclusion:
+    { not: [{ name: "Pressable" }, { testID: "loading" }] }.
+  index — pick N-th match from this step; otherwise all matches fan out into the next step.
 
-## Scoping with "within"
-- within: "LoginForm" — search only inside LoginForm
-- within: "Button:1/Pressable" — nested path with index
+SELECT (output fields)
+  Default ["mcpId", "name", "testID"] — props and bounds are opt-in.
+  bounds: { x, y, width, height, centerX, centerY } in PHYSICAL pixels,
+  top-left origin. null when the fiber has no mounted host view. centerX/
+  centerY feed straight into host__tap.
+  props: full serialized props (heavy). Pair with propsInclude:
+  ["key1","key2"] to keep only the props you actually need and avoid
+  pulling large style maps, data arrays, or nested element trees.
 
-## Coordinates (host__tap targets)
-- Pass \`select: ["mcpId", "name", "bounds"]\` to find_all to get tap coordinates without heavy props.
-- bounds = {x, y, width, height, centerX, centerY} in PHYSICAL PIXELS.
-- Use bounds.centerX/centerY directly with host__tap — no scaling needed.
-- bounds is null only when the component has no host view (unmounted, virtualized off-screen).
+RESPONSE
+  { matches: [...], total, truncated? } — total is the unrestricted match
+  count; when the result exceeds limit (default 50, max 500) truncated:
+  true is added and matches contains the first limit items in DFS order.
+  Narrow the query rather than cranking limit.
 
-## Saving tokens with select
-- \`select\` controls which fields appear in each result: mcpId, name, testID, props, bounds.
-- Default (no select): all fields except bounds. Include "bounds" for tap coordinates.
-- Omit "props" to cut response size ~90% when you only need names/IDs.
+  By default wrapper cascades are deduped: a fiber is hidden when any of
+  its ancestors is also a match, so PressableView → Pressable → View →
+  RCTView collapses to the topmost PressableView. Independent siblings
+  are kept. Pass dedup: false to see every layer.
 
-## Tips
-- mcpId is stable across renders (format: ComponentName:file:line)
-- Use find_all first to discover available components, then invoke or host__tap them
-- host__tap with bounds.centerX/centerY tests the real OS gesture pipeline; invoke bypasses it and calls the prop directly (faster, immune to overlay/gesture-arbitration issues, but doesn't exercise touch handlers)
-- Use screenshot after interactions to verify results`,
+TIPS
+  mcpId format "ComponentName:file:line" — stable across renders.
+  Use query to locate, then invoke (bypasses gesture pipeline) or host__tap
+  with bounds (real OS touch) to act. For one-shot real taps, tap_fiber
+  collapses both steps into a single call.
+  When stepping up via scope: "ancestors", prefer filtering by name (or
+  testID/mcpId) over guessing an index — ancestors count is brittle and
+  varies across RN versions.
+  \`text\` matches RENDERED text only — Text children content, not prop
+  values. To match "placeholder: Search" use \`props: { placeholder:
+  { contains: "Search" } }\`.`,
         name: 'fiber_tree',
         tools: {
             call_ref: {
-                description: 'Call a method on the native ref/instance of a component (e.g. focus, blur, measure). Use get_ref_methods first to see available methods.',
+                description: "Call a method on a component's native ref (focus, blur, measure, …). Use get_ref_methods first to see what's available.",
                 handler: (args) => {
                     const rootError = requireRoot();
                     if (rootError)
@@ -154,76 +318,16 @@ const fiberTreeModule = (options) => {
                 },
                 inputSchema: {
                     ...FIND_SCHEMA,
-                    args: { description: 'Arguments to pass to the method as array', type: 'array' },
+                    args: { description: 'Arguments passed to the method.', type: 'array' },
                     method: {
-                        description: 'Method name to call (e.g. "focus", "blur", "measure")',
+                        description: 'Method name to call.',
+                        examples: ['focus', 'blur', 'measure'],
                         type: 'string',
                     },
                 },
             },
-            find_all: {
-                description: 'Find all components matching a query (by testID, name, text, or props presence). Supports within for scoped search. Use select to control which fields are returned — e.g. select: ["mcpId", "name", "bounds"] for tap targeting without heavy props.',
-                handler: async (args) => {
-                    const rootError = requireRoot();
-                    if (rootError)
-                        return rootError;
-                    let root = (0, utils_1.getFiberRoot)();
-                    if (args.within) {
-                        const path = args.within.split('/');
-                        for (const segment of path) {
-                            root = findInRoot(root, segment);
-                            if (!root)
-                                return { error: `Parent "${args.within}" not found` };
-                        }
-                    }
-                    const query = {
-                        hasProps: args.hasProps,
-                        mcpId: args.mcpId,
-                        name: args.name,
-                        testID: args.testID,
-                        text: args.text,
-                    };
-                    const defaultFields = ['mcpId', 'name', 'props', 'testID'];
-                    const fields = new Set(Array.isArray(args.select) ? args.select : defaultFields);
-                    const fibers = (0, utils_1.findAllByQuery)(root, query);
-                    return Promise.all(fibers.map(async (fiber) => {
-                        const result = {};
-                        if (fields.has('bounds')) {
-                            result.bounds = await (0, utils_1.measureFiber)(fiber);
-                        }
-                        if (fields.has('mcpId')) {
-                            result.mcpId = fiber.memoizedProps?.['data-mcp-id'];
-                        }
-                        if (fields.has('name')) {
-                            result.name = (0, utils_1.getComponentName)(fiber);
-                        }
-                        if (fields.has('props')) {
-                            result.props = (0, utils_1.serializeProps)(fiber.memoizedProps);
-                        }
-                        if (fields.has('testID')) {
-                            result.testID = fiber.memoizedProps?.testID;
-                        }
-                        return result;
-                    }));
-                },
-                inputSchema: {
-                    hasProps: {
-                        description: 'Filter by props presence (array of prop names)',
-                        type: 'array',
-                    },
-                    mcpId: { description: 'data-mcp-id to match', type: 'string' },
-                    name: { description: 'Component name to match', type: 'string' },
-                    select: {
-                        description: 'Fields to include in each result. Available: mcpId, name, testID, props, bounds. Default (when omitted): all except bounds. Include "bounds" for physical-pixel tap coordinates. Omit "props" to save tokens.',
-                        type: 'array',
-                    },
-                    testID: { description: 'testID to match', type: 'string' },
-                    text: { description: 'Text content to match (substring)', type: 'string' },
-                    within: FIND_SCHEMA.within,
-                },
-            },
             get_children: {
-                description: 'Get children of a component found by testID, name, or text',
+                description: 'Get the children subtree of a single component.',
                 handler: (args) => {
                     const rootError = requireRoot();
                     if (rootError)
@@ -237,11 +341,11 @@ const fiberTreeModule = (options) => {
                 },
                 inputSchema: {
                     ...FIND_SCHEMA,
-                    depth: { description: 'Max depth to traverse (default: 10)', type: 'number' },
+                    depth: { description: 'Max traversal depth (default: 10).', type: 'number' },
                 },
             },
             get_component: {
-                description: 'Find a component by testID, name, or text and return its details. Use select to control root-level fields — e.g. select: ["name", "bounds"] to include tap coordinates without props.',
+                description: 'Find one component and return its details with children subtree (deep inspection). Use `query` for a flat list of matches.',
                 handler: async (args) => {
                     const rootError = requireRoot();
                     if (rootError)
@@ -279,19 +383,20 @@ const fiberTreeModule = (options) => {
                     return serialized;
                 },
                 inputSchema: {
-                    depth: { description: 'Max depth to traverse children (default: 3)', type: 'number' },
-                    mcpId: { description: 'data-mcp-id to search for', type: 'string' },
-                    name: { description: 'Component name to search for', type: 'string' },
+                    depth: { description: 'Max child traversal depth (default: 10).', type: 'number' },
+                    mcpId: { description: 'Stable data-mcp-id to match.', type: 'string' },
+                    name: { description: 'Component name to match.', type: 'string' },
                     select: {
-                        description: 'Fields to include on root node. Available: name, props, bounds. Include "bounds" for tap coordinates. Omit "props" to save tokens. Children are always included.',
+                        description: 'Fields to include on the root node. Available: name, props, bounds. Children are always included.',
+                        examples: [['name', 'bounds']],
                         type: 'array',
                     },
-                    testID: { description: 'testID to search for', type: 'string' },
-                    text: { description: 'Text content to search for', type: 'string' },
+                    testID: { description: 'testID to match.', type: 'string' },
+                    text: { description: 'Rendered text substring.', type: 'string' },
                 },
             },
             get_props: {
-                description: 'Get all props of a component found by testID, name, or text',
+                description: 'Get all props of one component.',
                 handler: (args) => {
                     const rootError = requireRoot();
                     if (rootError)
@@ -307,7 +412,7 @@ const fiberTreeModule = (options) => {
                 inputSchema: FIND_SCHEMA,
             },
             get_ref_methods: {
-                description: 'List available methods on the native ref/instance of a component',
+                description: "List available methods on a component's native ref.",
                 handler: (args) => {
                     const rootError = requireRoot();
                     if (rootError)
@@ -327,7 +432,7 @@ const fiberTreeModule = (options) => {
                 inputSchema: FIND_SCHEMA,
             },
             get_tree: {
-                description: 'Get the React component tree. Returns component names, types, props, and testIDs.',
+                description: 'Dump the full React component tree from the root fiber.',
                 handler: (args) => {
                     const rootError = requireRoot();
                     if (rootError)
@@ -337,11 +442,11 @@ const fiberTreeModule = (options) => {
                     return (0, utils_1.serializeFiber)(root, depth);
                 },
                 inputSchema: {
-                    depth: { description: 'Max depth to traverse (default: 3)', type: 'number' },
+                    depth: { description: 'Max traversal depth (default: 10).', type: 'number' },
                 },
             },
             invoke: {
-                description: 'Call any callback prop on a component found by testID, name, or text. Use this to simulate press, scroll, text input, or any other interaction. Bypasses the OS gesture pipeline — faster and immune to overlay/gesture-arbitration issues, but does not exercise touch handlers. Prefer host__tap (with fiber_tree bounds) when you want to test the real user touch path.',
+                description: "Call a prop's callback function directly from JS. For simulating a user tap, prefer host__tap_fiber — it runs the real OS gesture pipeline so Pressable feedback, gesture responders, and hit-test behave as under a real finger. invoke still works for any callback when you specifically want the JS-only path (component off-screen, skipping the gesture recognizer, or driving a non-gesture prop), but it is not the default for user-behavior simulation.",
                 handler: (args) => {
                     const rootError = requireRoot();
                     if (rootError)
@@ -367,15 +472,149 @@ const fiberTreeModule = (options) => {
                 inputSchema: {
                     ...FIND_SCHEMA,
                     args: {
-                        description: 'Arguments to pass to the callback as array (e.g. [true] or ["text"])',
+                        description: 'Arguments passed to the callback.',
+                        examples: [[true], ['text']],
                         type: 'array',
                     },
                     callback: {
-                        description: 'Name of the callback prop to call (e.g. "onPress", "onChangeText")',
+                        description: 'Callback prop name.',
+                        examples: ['onSkip', 'onUpdate', 'onCompleted'],
                         type: 'string',
                     },
                 },
             },
+            query: {
+                description: 'Chain-based fiber search. Each step narrows the result set via `scope` + criteria; multiple matches fan out into the next step. Returns { matches, total, truncated? }. See the module description for scope, criteria, select and response reference.',
+                handler: async (args) => {
+                    const rootError = requireRoot();
+                    if (rootError)
+                        return rootError;
+                    const root = (0, utils_1.getFiberRoot)();
+                    const steps = args.steps;
+                    if (!Array.isArray(steps) || steps.length === 0) {
+                        return { error: 'query requires a non-empty `steps` array' };
+                    }
+                    const limit = typeof args.limit === 'number' && args.limit > 0
+                        ? Math.min(Math.floor(args.limit), QUERY_LIMIT_MAX)
+                        : QUERY_LIMIT_DEFAULT;
+                    const dedup = args.dedup !== false;
+                    const useCache = args.cache !== false;
+                    const onlyVisible = args.onlyVisible === true;
+                    const runtime = { navigationRef, root };
+                    const rawMatches = runCachedQuery(runtime, steps, useCache);
+                    let all = dedup ? dedupAncestors(rawMatches) : rawMatches;
+                    let visibleRect = null;
+                    const boundsCache = new Map();
+                    const measure = async (fiber) => {
+                        if (boundsCache.has(fiber))
+                            return boundsCache.get(fiber) ?? null;
+                        const b = await (0, utils_1.measureFiber)(fiber);
+                        boundsCache.set(fiber, b);
+                        return b;
+                    };
+                    if (onlyVisible) {
+                        visibleRect = getVisibleRect();
+                        if (visibleRect) {
+                            const rect = visibleRect;
+                            const measured = await Promise.all(all.map(async (fiber) => {
+                                return { bounds: await measure(fiber), fiber };
+                            }));
+                            all = measured
+                                .filter(({ bounds }) => {
+                                return bounds && intersectsRect(bounds, rect);
+                            })
+                                .map(({ fiber }) => {
+                                return fiber;
+                            });
+                        }
+                    }
+                    const total = all.length;
+                    const truncated = total > limit;
+                    const picked = truncated ? all.slice(0, limit) : all;
+                    const fields = new Set(Array.isArray(args.select) ? args.select : QUERY_DEFAULT_FIELDS);
+                    const propsInclude = Array.isArray(args.propsInclude)
+                        ? new Set(args.propsInclude)
+                        : null;
+                    const matches = await Promise.all(picked.map(async (fiber) => {
+                        const result = {};
+                        if (fields.has('bounds')) {
+                            result.bounds = await measure(fiber);
+                        }
+                        if (fields.has('mcpId')) {
+                            result.mcpId = fiber.memoizedProps?.['data-mcp-id'];
+                        }
+                        if (fields.has('name')) {
+                            result.name = (0, utils_1.getComponentName)(fiber);
+                        }
+                        if (fields.has('props')) {
+                            const full = (0, utils_1.serializeProps)(fiber.memoizedProps);
+                            if (propsInclude) {
+                                const filtered = {};
+                                for (const key of propsInclude) {
+                                    if (key in full)
+                                        filtered[key] = full[key];
+                                }
+                                result.props = filtered;
+                            }
+                            else {
+                                result.props = full;
+                            }
+                        }
+                        if (fields.has('testID')) {
+                            result.testID = fiber.memoizedProps?.testID;
+                        }
+                        return result;
+                    }));
+                    const response = { matches, total };
+                    if (truncated)
+                        response.truncated = true;
+                    return response;
+                },
+                inputSchema: {
+                    cache: {
+                        description: 'Reuse the match set when the React tree has not committed since the previous identical steps — detected via fiber root pointer equality. Default true; pass false to force a fresh traversal.',
+                        type: 'boolean',
+                    },
+                    dedup: {
+                        description: 'Drop wrapper cascades — a fiber is removed when any of its ancestors is also in the match set (PressableView → Pressable → View → RCTView collapses to the topmost). Independent siblings with overlapping bounds are kept. Default true; pass false to keep every match.',
+                        type: 'boolean',
+                    },
+                    limit: {
+                        description: `Max matches to return (default ${QUERY_LIMIT_DEFAULT}, max ${QUERY_LIMIT_MAX}). truncated: true is added when total exceeds limit.`,
+                        type: 'number',
+                    },
+                    onlyVisible: {
+                        description: 'Drop matches whose measured bounds do not intersect the current window rectangle (physical pixels). Also drops fibers with no measurable host view — usually virtualized or unmounted. Halves results on long lists.',
+                        type: 'boolean',
+                    },
+                    propsInclude: {
+                        description: 'When select includes "props", keep only these prop names. Unknown keys are silently dropped. Omit for full serialization.',
+                        examples: [
+                            ['placeholder', 'value'],
+                            ['title', 'disabled'],
+                        ],
+                        type: 'array',
+                    },
+                    select: {
+                        description: `Output fields: mcpId, name, testID, props, bounds. Default ${JSON.stringify(QUERY_DEFAULT_FIELDS)}.`,
+                        examples: [
+                            ['mcpId', 'name', 'bounds'],
+                            ['mcpId', 'name', 'props'],
+                        ],
+                        type: 'array',
+                    },
+                    steps: {
+                        description: 'Ordered steps: [{ scope?, name?, mcpId?, testID?, text?, hasProps?, props?, index? }]. See module description for full semantics.',
+                        examples: [
+                            [{ hasProps: ['onPress'] }],
+                            [{ name: 'HomeScreen' }, { name: 'ProductCard' }],
+                            [{ testID: 'favorite-icon' }, { index: 0, name: 'ProductCard', scope: 'ancestors' }],
+                            [{ props: { placeholder: { contains: 'Search' } } }],
+                        ],
+                        type: 'array',
+                    },
+                },
+            },
         },
     };
 };