@cucumber/react-components 24.2.0 → 24.4.0

package/dist/hooks/useSearchResult.js

@@ -0,0 +1,58 @@
+import { useEffect, useMemo, useState } from 'react';
+import { createSearchIndex } from '../search/index.js';
+import { useQueries } from './useQueries.js';
+import { useSearch } from './useSearch.js';
+/**
+ * Creates and populates a search index from the loaded Gherkin documents, runs the current search
+ * term against it, and returns a discriminated result describing the outcome. Consumers narrow on
+ * `result.status` and don't need to know whether a search term is present.
+ */
+export function useSearchResult() {
+    const { gherkinQuery } = useQueries();
+    const gherkinDocuments = useMemo(() => gherkinQuery.getGherkinDocuments(), [gherkinQuery]);
+    const { searchTerm } = useSearch();
+    const [searchIndex, setSearchIndex] = useState();
+    const [result, setResult] = useState({ status: 'WAITING' });
+    useEffect(() => {
+        createSearchIndex(gherkinDocuments)
+            .then((created) => setSearchIndex(created))
+            .catch((error) => {
+            console.error('Failed to create search index:', error);
+            setSearchIndex(new Error('Failed to create search index', { cause: error }));
+        });
+    }, [gherkinDocuments]);
+    useEffect(() => {
+        if (!searchTerm) {
+            setResult({ status: 'NOOP' });
+            return;
+        }
+        if (searchIndex === undefined) {
+            // search index is not ready yet
+            setResult({ status: 'WAITING' });
+            return;
+        }
+        if (searchIndex instanceof Error) {
+            setResult({ status: 'ERROR', error: searchIndex });
+            return;
+        }
+        let active = true;
+        searchIndex
+            .search(searchTerm)
+            .then((hits) => {
+            if (active) {
+                setResult({ status: 'SUCCESS', hits });
+            }
+        })
+            .catch((error) => {
+            console.error('Search failed:', error);
+            if (active) {
+                setResult({ status: 'ERROR', error: new Error('Search failed', { cause: error }) });
+            }
+        });
+        return () => {
+            active = false;
+        };
+    }, [searchIndex, searchTerm]);
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/useTestCaseStarted.d.ts

@@ -0,0 +1,7 @@
+import type { TestCaseStarted } from '@cucumber/messages';
+/**
+ * Finds the corresponding TestCaseStarted for an Example or Scenario node from a Gherkin
+ * document
+ * @param nodeId the Gherkin node id
+ */
+export declare function useTestCaseStarted(nodeId: string): TestCaseStarted | undefined;

package/dist/hooks/useTestCaseStarted.js

@@ -0,0 +1,20 @@
+import { useMemo } from 'react';
+import { useQueries } from './useQueries.js';
+/**
+ * Finds the corresponding TestCaseStarted for an Example or Scenario node from a Gherkin
+ * document
+ * @param nodeId the Gherkin node id
+ */
+export function useTestCaseStarted(nodeId) {
+    const { cucumberQuery } = useQueries();
+    return useMemo(() => {
+        for (const testCaseStarted of cucumberQuery.findAllTestCaseStarted()) {
+            const pickle = cucumberQuery.findPickleBy(testCaseStarted);
+            const closestNodeId = pickle?.astNodeIds.at(-1);
+            if (closestNodeId === nodeId) {
+                return testCaseStarted;
+            }
+        }
+    }, [cucumberQuery, nodeId]);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlVGVzdENhc2VTdGFydGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3VzZVRlc3RDYXNlU3RhcnRlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sT0FBTyxDQUFBO0FBRS9CLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTtBQUU1Qzs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLGtCQUFrQixDQUFDLE1BQWM7SUFDL0MsTUFBTSxFQUFFLGFBQWEsRUFBRSxHQUFHLFVBQVUsRUFBRSxDQUFBO0lBQ3RDLE9BQU8sT0FBTyxDQUFDLEdBQUcsRUFBRTtRQUNsQixLQUFLLE1BQU0sZUFBZSxJQUFJLGFBQWEsQ0FBQyxzQkFBc0IsRUFBRSxFQUFFLENBQUM7WUFDckUsTUFBTSxNQUFNLEdBQUcsYUFBYSxDQUFDLFlBQVksQ0FBQyxlQUFlLENBQUMsQ0FBQTtZQUMxRCxNQUFNLGFBQWEsR0FBRyxNQUFNLEVBQUUsVUFBVSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO1lBQy9DLElBQUksYUFBYSxLQUFLLE1BQU0sRUFBRSxDQUFDO2dCQUM3QixPQUFPLGVBQWUsQ0FBQTtZQUN4QixDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUMsRUFBRSxDQUFDLGFBQWEsRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUFBO0FBQzdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFRlc3RDYXNlU3RhcnRlZCB9IGZyb20gJ0BjdWN1bWJlci9tZXNzYWdlcydcbmltcG9ydCB7IHVzZU1lbW8gfSBmcm9tICdyZWFjdCdcblxuaW1wb3J0IHsgdXNlUXVlcmllcyB9IGZyb20gJy4vdXNlUXVlcmllcy5qcydcblxuLyoqXG4gKiBGaW5kcyB0aGUgY29ycmVzcG9uZGluZyBUZXN0Q2FzZVN0YXJ0ZWQgZm9yIGFuIEV4YW1wbGUgb3IgU2NlbmFyaW8gbm9kZSBmcm9tIGEgR2hlcmtpblxuICogZG9jdW1lbnRcbiAqIEBwYXJhbSBub2RlSWQgdGhlIEdoZXJraW4gbm9kZSBpZFxuICovXG5leHBvcnQgZnVuY3Rpb24gdXNlVGVzdENhc2VTdGFydGVkKG5vZGVJZDogc3RyaW5nKTogVGVzdENhc2VTdGFydGVkIHwgdW5kZWZpbmVkIHtcbiAgY29uc3QgeyBjdWN1bWJlclF1ZXJ5IH0gPSB1c2VRdWVyaWVzKClcbiAgcmV0dXJuIHVzZU1lbW8oKCkgPT4ge1xuICAgIGZvciAoY29uc3QgdGVzdENhc2VTdGFydGVkIG9mIGN1Y3VtYmVyUXVlcnkuZmluZEFsbFRlc3RDYXNlU3RhcnRlZCgpKSB7XG4gICAgICBjb25zdCBwaWNrbGUgPSBjdWN1bWJlclF1ZXJ5LmZpbmRQaWNrbGVCeSh0ZXN0Q2FzZVN0YXJ0ZWQpXG4gICAgICBjb25zdCBjbG9zZXN0Tm9kZUlkID0gcGlja2xlPy5hc3ROb2RlSWRzLmF0KC0xKVxuICAgICAgaWYgKGNsb3Nlc3ROb2RlSWQgPT09IG5vZGVJZCkge1xuICAgICAgICByZXR1cm4gdGVzdENhc2VTdGFydGVkXG4gICAgICB9XG4gICAgfVxuICB9LCBbY3VjdW1iZXJRdWVyeSwgbm9kZUlkXSlcbn1cbiJdfQ==

package/dist/{src/hooks → hooks}/useTestRunHooks.d.ts

@@ -1,8 +1,7 @@
-import { Hook, TestRunHookFinished } from '@cucumber/messages';
+import type { Hook, TestRunHookFinished } from '@cucumber/messages';
 type RunHooksList = {
     testRunHookFinished: TestRunHookFinished;
     hook: Hook;
 }[];
 export declare function useTestRunHooks(): RunHooksList;
 export {};
-//# sourceMappingURL=useTestRunHooks.d.ts.map

package/dist/hooks/useTestRunHooks.js

@@ -0,0 +1,14 @@
+import { ensure } from '../ensure.js';
+import { useQueries } from './useQueries.js';
+export function useTestRunHooks() {
+    const { cucumberQuery } = useQueries();
+    const testRunHooksFinished = cucumberQuery.findAllTestRunHookFinished();
+    return testRunHooksFinished.map((testRunHookFinished) => {
+        const hook = ensure(cucumberQuery.findHookBy(testRunHookFinished), 'Expected testRunHookFinished to resolve with a hook');
+        return {
+            testRunHookFinished,
+            hook,
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlVGVzdFJ1bkhvb2tzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3VzZVRlc3RSdW5Ib29rcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sY0FBYyxDQUFBO0FBQ3JDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTtBQUk1QyxNQUFNLFVBQVUsZUFBZTtJQUM3QixNQUFNLEVBQUUsYUFBYSxFQUFFLEdBQUcsVUFBVSxFQUFFLENBQUE7SUFDdEMsTUFBTSxvQkFBb0IsR0FDeEIsYUFBYSxDQUFDLDBCQUEwQixFQUFFLENBQUE7SUFFNUMsT0FBTyxvQkFBb0IsQ0FBQyxHQUFHLENBQUMsQ0FBQyxtQkFBbUIsRUFBRSxFQUFFO1FBQ3RELE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FDakIsYUFBYSxDQUFDLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyxFQUM3QyxxREFBcUQsQ0FDdEQsQ0FBQTtRQUVELE9BQU87WUFDTCxtQkFBbUI7WUFDbkIsSUFBSTtTQUNMLENBQUE7SUFDSCxDQUFDLENBQUMsQ0FBQTtBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEhvb2ssIFRlc3RSdW5Ib29rRmluaXNoZWQgfSBmcm9tICdAY3VjdW1iZXIvbWVzc2FnZXMnXG5cbmltcG9ydCB7IGVuc3VyZSB9IGZyb20gJy4uL2Vuc3VyZS5qcydcbmltcG9ydCB7IHVzZVF1ZXJpZXMgfSBmcm9tICcuL3VzZVF1ZXJpZXMuanMnXG5cbnR5cGUgUnVuSG9va3NMaXN0ID0geyB0ZXN0UnVuSG9va0ZpbmlzaGVkOiBUZXN0UnVuSG9va0ZpbmlzaGVkOyBob29rOiBIb29rIH1bXVxuXG5leHBvcnQgZnVuY3Rpb24gdXNlVGVzdFJ1bkhvb2tzKCk6IFJ1bkhvb2tzTGlzdCB7XG4gIGNvbnN0IHsgY3VjdW1iZXJRdWVyeSB9ID0gdXNlUXVlcmllcygpXG4gIGNvbnN0IHRlc3RSdW5Ib29rc0ZpbmlzaGVkOiBSZWFkb25seUFycmF5PFRlc3RSdW5Ib29rRmluaXNoZWQ+ID1cbiAgICBjdWN1bWJlclF1ZXJ5LmZpbmRBbGxUZXN0UnVuSG9va0ZpbmlzaGVkKClcblxuICByZXR1cm4gdGVzdFJ1bkhvb2tzRmluaXNoZWQubWFwKCh0ZXN0UnVuSG9va0ZpbmlzaGVkKSA9PiB7XG4gICAgY29uc3QgaG9vayA9IGVuc3VyZShcbiAgICAgIGN1Y3VtYmVyUXVlcnkuZmluZEhvb2tCeSh0ZXN0UnVuSG9va0ZpbmlzaGVkKSxcbiAgICAgICdFeHBlY3RlZCB0ZXN0UnVuSG9va0ZpbmlzaGVkIHRvIHJlc29sdmUgd2l0aCBhIGhvb2snXG4gICAgKVxuXG4gICAgcmV0dXJuIHtcbiAgICAgIHRlc3RSdW5Ib29rRmluaXNoZWQsXG4gICAgICBob29rLFxuICAgIH1cbiAgfSlcbn1cbiJdfQ==

package/dist/{src/index.js → index.d.ts}

@@ -1,3 +1,2 @@
 export * from './components/index.js';
 export * from './hooks/index.js';
-//# sourceMappingURL=index.js.map

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './components/index.js';
+export * from './hooks/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQTtBQUNyQyxjQUFjLGtCQUFrQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL2luZGV4LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9ob29rcy9pbmRleC5qcydcbiJdfQ==

package/dist/{src/isTagExpression.d.ts → isTagExpression.d.ts}

@@ -1,2 +1 @@
 export default function isTagExpression(expression: string): boolean;
-//# sourceMappingURL=isTagExpression.d.ts.map

package/dist/isTagExpression.js

@@ -0,0 +1,5 @@
+export default function isTagExpression(expression) {
+    const tagExpression = /^\s*((@[^\s]+\s*)|(and\s+)|(or\s+)|(not\s+)|\(|\))+\s*$/;
+    return !!tagExpression.exec(expression);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXNUYWdFeHByZXNzaW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2lzVGFnRXhwcmVzc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsT0FBTyxVQUFVLGVBQWUsQ0FBQyxVQUFrQjtJQUN4RCxNQUFNLGFBQWEsR0FBRyx5REFBeUQsQ0FBQTtJQUMvRSxPQUFPLENBQUMsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFBO0FBQ3pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBpc1RhZ0V4cHJlc3Npb24oZXhwcmVzc2lvbjogc3RyaW5nKTogYm9vbGVhbiB7XG4gIGNvbnN0IHRhZ0V4cHJlc3Npb24gPSAvXlxccyooKEBbXlxcc10rXFxzKil8KGFuZFxccyspfChvclxccyspfChub3RcXHMrKXxcXCh8XFwpKStcXHMqJC9cbiAgcmV0dXJuICEhdGFnRXhwcmVzc2lvbi5leGVjKGV4cHJlc3Npb24pXG59XG4iXX0=

package/dist/search/FeatureSearch.d.ts

@@ -0,0 +1,12 @@
+import type { GherkinDocument } from '@cucumber/messages';
+import type { IndexHit, TypedIndex } from './types.js';
+/**
+ * A little different to the other indexes - a Feature doesn't have its own id,
+ * so we use the uri of the GherkinDocument as a pointer
+ */
+export declare class FeatureSearch implements TypedIndex<GherkinDocument> {
+    private readonly index;
+    constructor();
+    search(term: string): Promise<ReadonlyArray<IndexHit>>;
+    add(gherkinDocument: GherkinDocument, _uri: string): Promise<this>;
+}

package/dist/search/FeatureSearch.js

@@ -0,0 +1,39 @@
+import { create, insert, search } from '@orama/orama';
+const schema = {
+    name: 'string',
+    description: 'string',
+};
+/**
+ * A little different to the other indexes - a Feature doesn't have its own id,
+ * so we use the uri of the GherkinDocument as a pointer
+ */
+export class FeatureSearch {
+    index;
+    constructor() {
+        this.index = create({
+            schema,
+            sort: { enabled: false },
+        });
+    }
+    async search(term) {
+        const { hits } = await search(this.index, {
+            term,
+        });
+        return hits.map((hit) => ({ uri: hit.id, id: hit.id }));
+    }
+    async add(gherkinDocument, _uri) {
+        if (!gherkinDocument.feature) {
+            return this;
+        }
+        if (!gherkinDocument.uri) {
+            throw new Error('Missing uri on gherkinDocument');
+        }
+        await insert(this.index, {
+            id: gherkinDocument.uri,
+            name: gherkinDocument.feature.name,
+            description: gherkinDocument.feature.description,
+        });
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/search/ScenarioLikeSearch.d.ts

@@ -0,0 +1,19 @@
+import { type TypedIndex } from './types.js';
+export interface ScenarioLike {
+    id: string;
+    name: string;
+    description: string;
+}
+/**
+ * Can be used for Backgrounds, Scenarios and Rules, searching against the
+ * name and description
+ */
+export declare class ScenarioLikeSearch<T extends ScenarioLike> implements TypedIndex<T> {
+    private readonly index;
+    constructor();
+    search(term: string): Promise<{
+        uri: string;
+        id: string;
+    }[]>;
+    add(item: T, uri: string): Promise<this>;
+}

package/dist/search/ScenarioLikeSearch.js

@@ -0,0 +1,37 @@
+import { create, insert, search } from '@orama/orama';
+import { ID_SEPARATOR } from './types.js';
+const schema = {
+    name: 'string',
+    description: 'string',
+};
+/**
+ * Can be used for Backgrounds, Scenarios and Rules, searching against the
+ * name and description
+ */
+export class ScenarioLikeSearch {
+    index;
+    constructor() {
+        this.index = create({
+            schema,
+            sort: { enabled: false },
+        });
+    }
+    async search(term) {
+        const { hits } = await search(this.index, {
+            term,
+        });
+        return hits.map((hit) => {
+            const [uri, id] = hit.id.split(ID_SEPARATOR);
+            return { uri, id };
+        });
+    }
+    async add(item, uri) {
+        await insert(this.index, {
+            id: uri + ID_SEPARATOR + item.id,
+            name: item.name,
+            description: item.description,
+        });
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NlbmFyaW9MaWtlU2VhcmNoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlYXJjaC9TY2VuYXJpb0xpa2VTZWFyY2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQWMsTUFBTSxFQUFFLE1BQU0sY0FBYyxDQUFBO0FBRWpFLE9BQU8sRUFBRSxZQUFZLEVBQW1CLE1BQU0sWUFBWSxDQUFBO0FBRTFELE1BQU0sTUFBTSxHQUFHO0lBQ2IsSUFBSSxFQUFFLFFBQVE7SUFDZCxXQUFXLEVBQUUsUUFBUTtDQUNiLENBQUE7QUFRVjs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBQ1osS0FBSyxDQUFzQjtJQUU1QztRQUNFLElBQUksQ0FBQyxLQUFLLEdBQUcsTUFBTSxDQUFDO1lBQ2xCLE1BQU07WUFDTixJQUFJLEVBQUUsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFO1NBQ3pCLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFFRCxLQUFLLENBQUMsTUFBTSxDQUFDLElBQVk7UUFDdkIsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLE1BQU0sTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUU7WUFDeEMsSUFBSTtTQUNMLENBQUMsQ0FBQTtRQUNGLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO1lBQ3RCLE1BQU0sQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEdBQUcsR0FBRyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLENBQUE7WUFDNUMsT0FBTyxFQUFFLEdBQUcsRUFBRSxFQUFFLEVBQUUsQ0FBQTtRQUNwQixDQUFDLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFFRCxLQUFLLENBQUMsR0FBRyxDQUFDLElBQU8sRUFBRSxHQUFXO1FBQzVCLE1BQU0sTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUU7WUFDdkIsRUFBRSxFQUFFLEdBQUcsR0FBRyxZQUFZLEdBQUcsSUFBSSxDQUFDLEVBQUU7WUFDaEMsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1lBQ2YsV0FBVyxFQUFFLElBQUksQ0FBQyxXQUFXO1NBQzlCLENBQUMsQ0FBQTtRQUNGLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlLCBpbnNlcnQsIHR5cGUgT3JhbWEsIHNlYXJjaCB9IGZyb20gJ0BvcmFtYS9vcmFtYSdcblxuaW1wb3J0IHsgSURfU0VQQVJBVE9SLCB0eXBlIFR5cGVkSW5kZXggfSBmcm9tICcuL3R5cGVzLmpzJ1xuXG5jb25zdCBzY2hlbWEgPSB7XG4gIG5hbWU6ICdzdHJpbmcnLFxuICBkZXNjcmlwdGlvbjogJ3N0cmluZycsXG59IGFzIGNvbnN0XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2NlbmFyaW9MaWtlIHtcbiAgaWQ6IHN0cmluZ1xuICBuYW1lOiBzdHJpbmdcbiAgZGVzY3JpcHRpb246IHN0cmluZ1xufVxuXG4vKipcbiAqIENhbiBiZSB1c2VkIGZvciBCYWNrZ3JvdW5kcywgU2NlbmFyaW9zIGFuZCBSdWxlcywgc2VhcmNoaW5nIGFnYWluc3QgdGhlXG4gKiBuYW1lIGFuZCBkZXNjcmlwdGlvblxuICovXG5leHBvcnQgY2xhc3MgU2NlbmFyaW9MaWtlU2VhcmNoPFQgZXh0ZW5kcyBTY2VuYXJpb0xpa2U+IGltcGxlbWVudHMgVHlwZWRJbmRleDxUPiB7XG4gIHByaXZhdGUgcmVhZG9ubHkgaW5kZXg6IE9yYW1hPHR5cGVvZiBzY2hlbWE+XG5cbiAgY29uc3RydWN0b3IoKSB7XG4gICAgdGhpcy5pbmRleCA9IGNyZWF0ZSh7XG4gICAgICBzY2hlbWEsXG4gICAgICBzb3J0OiB7IGVuYWJsZWQ6IGZhbHNlIH0sXG4gICAgfSlcbiAgfVxuXG4gIGFzeW5jIHNlYXJjaCh0ZXJtOiBzdHJpbmcpIHtcbiAgICBjb25zdCB7IGhpdHMgfSA9IGF3YWl0IHNlYXJjaCh0aGlzLmluZGV4LCB7XG4gICAgICB0ZXJtLFxuICAgIH0pXG4gICAgcmV0dXJuIGhpdHMubWFwKChoaXQpID0+IHtcbiAgICAgIGNvbnN0IFt1cmksIGlkXSA9IGhpdC5pZC5zcGxpdChJRF9TRVBBUkFUT1IpXG4gICAgICByZXR1cm4geyB1cmksIGlkIH1cbiAgICB9KVxuICB9XG5cbiAgYXN5bmMgYWRkKGl0ZW06IFQsIHVyaTogc3RyaW5nKTogUHJvbWlzZTx0aGlzPiB7XG4gICAgYXdhaXQgaW5zZXJ0KHRoaXMuaW5kZXgsIHtcbiAgICAgIGlkOiB1cmkgKyBJRF9TRVBBUkFUT1IgKyBpdGVtLmlkLFxuICAgICAgbmFtZTogaXRlbS5uYW1lLFxuICAgICAgZGVzY3JpcHRpb246IGl0ZW0uZGVzY3JpcHRpb24sXG4gICAgfSlcbiAgICByZXR1cm4gdGhpc1xuICB9XG59XG4iXX0=

package/dist/search/StepSearch.d.ts

@@ -0,0 +1,11 @@
+import type { Step } from '@cucumber/messages';
+import { type TypedIndex } from './types.js';
+export declare class StepSearch implements TypedIndex<Step> {
+    private readonly index;
+    constructor();
+    search(term: string): Promise<{
+        uri: string;
+        id: string;
+    }[]>;
+    add(step: Step, uri: string): Promise<this>;
+}

package/dist/search/StepSearch.js

@@ -0,0 +1,40 @@
+import { create, insert, search } from '@orama/orama';
+import { ID_SEPARATOR } from './types.js';
+const schema = {
+    keyword: 'string',
+    text: 'string',
+    docString: 'string',
+    dataTable: 'string[]',
+};
+export class StepSearch {
+    index;
+    constructor() {
+        this.index = create({
+            schema,
+            sort: { enabled: false },
+        });
+    }
+    async search(term) {
+        const { hits } = await search(this.index, {
+            term,
+            boost: {
+                text: 2,
+            },
+        });
+        return hits.map((hit) => {
+            const [uri, id] = hit.id.split(ID_SEPARATOR);
+            return { uri, id };
+        });
+    }
+    async add(step, uri) {
+        await insert(this.index, {
+            id: uri + ID_SEPARATOR + step.id,
+            keyword: step.keyword,
+            text: step.text,
+            docString: step.docString?.content,
+            dataTable: step.dataTable?.rows.flatMap((row) => row.cells).map((cell) => cell.value),
+        });
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/search/TextSearch.d.ts

@@ -0,0 +1,11 @@
+import type { GherkinDocument } from '@cucumber/messages';
+import type { SearchHits, SearchIndex } from './types.js';
+export declare class TextSearch implements SearchIndex {
+    private readonly featureSearch;
+    private readonly backgroundSearch;
+    private readonly ruleSearch;
+    private readonly scenarioSearch;
+    private readonly stepSearch;
+    search(query: string): Promise<SearchHits>;
+    add(gherkinDocument: GherkinDocument): Promise<void>;
+}

package/dist/search/TextSearch.js

@@ -0,0 +1,67 @@
+import { walkGherkinDocument } from '@cucumber/gherkin-utils';
+import { FeatureSearch } from './FeatureSearch.js';
+import { ScenarioLikeSearch } from './ScenarioLikeSearch.js';
+import { StepSearch } from './StepSearch.js';
+export class TextSearch {
+    featureSearch = new FeatureSearch();
+    backgroundSearch = new ScenarioLikeSearch();
+    ruleSearch = new ScenarioLikeSearch();
+    scenarioSearch = new ScenarioLikeSearch();
+    stepSearch = new StepSearch();
+    async search(query) {
+        const [featureHits, backgroundHits, ruleHits, scenarioHits, stepHits] = await Promise.all([
+            this.featureSearch.search(query),
+            this.backgroundSearch.search(query),
+            this.ruleSearch.search(query),
+            this.scenarioSearch.search(query),
+            this.stepSearch.search(query),
+        ]);
+        // an empty map is a valid result meaning nothing matched
+        const map = new Map();
+        const getOrDefault = (uri) => {
+            let entry = map.get(uri);
+            if (!entry) {
+                entry = {
+                    feature: false,
+                    background: new Set(),
+                    rule: new Set(),
+                    scenario: new Set(),
+                    step: new Set(),
+                };
+                map.set(uri, entry);
+            }
+            return entry;
+        };
+        for (const hit of featureHits) {
+            getOrDefault(hit.uri).feature = true;
+        }
+        for (const hit of backgroundHits) {
+            getOrDefault(hit.uri).background.add(hit.id);
+        }
+        for (const hit of ruleHits) {
+            getOrDefault(hit.uri).rule.add(hit.id);
+        }
+        for (const hit of scenarioHits) {
+            getOrDefault(hit.uri).scenario.add(hit.id);
+        }
+        for (const hit of stepHits) {
+            getOrDefault(hit.uri).step.add(hit.id);
+        }
+        return map;
+    }
+    async add(gherkinDocument) {
+        const uri = gherkinDocument.uri;
+        if (!uri) {
+            return;
+        }
+        const promises = walkGherkinDocument(gherkinDocument, [], {
+            feature: (_feature, acc) => [...acc, this.featureSearch.add(gherkinDocument, uri)],
+            background: (background, acc) => [...acc, this.backgroundSearch.add(background, uri)],
+            rule: (rule, acc) => [...acc, this.ruleSearch.add(rule, uri)],
+            scenario: (scenario, acc) => [...acc, this.scenarioSearch.add(scenario, uri)],
+            step: (step, acc) => [...acc, this.stepSearch.add(step, uri)],
+        });
+        await Promise.all(promises);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/search/createSearchIndex.d.ts

@@ -0,0 +1,6 @@
+import type { GherkinDocument } from '@cucumber/messages';
+import type { SearchIndex } from './types.js';
+/**
+ * Creates a search index that supports querying by term
+ */
+export declare function createSearchIndex(gherkinDocuments: ReadonlyArray<GherkinDocument>): Promise<SearchIndex>;

package/dist/search/createSearchIndex.js

@@ -0,0 +1,10 @@
+import { TextSearch } from './TextSearch.js';
+/**
+ * Creates a search index that supports querying by term
+ */
+export async function createSearchIndex(gherkinDocuments) {
+    const textSearch = new TextSearch();
+    await Promise.all(gherkinDocuments.map((gherkinDocument) => textSearch.add(gherkinDocument)));
+    return textSearch;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlU2VhcmNoSW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VhcmNoL2NyZWF0ZVNlYXJjaEluZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTtBQUc1Qzs7R0FFRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsaUJBQWlCLENBQ3JDLGdCQUFnRDtJQUVoRCxNQUFNLFVBQVUsR0FBRyxJQUFJLFVBQVUsRUFBRSxDQUFBO0lBQ25DLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsQ0FBQyxlQUFlLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQzdGLE9BQU8sVUFBVSxDQUFBO0FBQ25CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEdoZXJraW5Eb2N1bWVudCB9IGZyb20gJ0BjdWN1bWJlci9tZXNzYWdlcydcblxuaW1wb3J0IHsgVGV4dFNlYXJjaCB9IGZyb20gJy4vVGV4dFNlYXJjaC5qcydcbmltcG9ydCB0eXBlIHsgU2VhcmNoSW5kZXggfSBmcm9tICcuL3R5cGVzLmpzJ1xuXG4vKipcbiAqIENyZWF0ZXMgYSBzZWFyY2ggaW5kZXggdGhhdCBzdXBwb3J0cyBxdWVyeWluZyBieSB0ZXJtXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBjcmVhdGVTZWFyY2hJbmRleChcbiAgZ2hlcmtpbkRvY3VtZW50czogUmVhZG9ubHlBcnJheTxHaGVya2luRG9jdW1lbnQ+XG4pOiBQcm9taXNlPFNlYXJjaEluZGV4PiB7XG4gIGNvbnN0IHRleHRTZWFyY2ggPSBuZXcgVGV4dFNlYXJjaCgpXG4gIGF3YWl0IFByb21pc2UuYWxsKGdoZXJraW5Eb2N1bWVudHMubWFwKChnaGVya2luRG9jdW1lbnQpID0+IHRleHRTZWFyY2guYWRkKGdoZXJraW5Eb2N1bWVudCkpKVxuICByZXR1cm4gdGV4dFNlYXJjaFxufVxuIl19

package/dist/search/deriveLineageConstraints.d.ts

@@ -0,0 +1,7 @@
+import type { Pickle } from '@cucumber/messages';
+import type { Lineage } from '@cucumber/query';
+import type { LineageConstraints } from './types.js';
+export declare function deriveLineageConstraints(items: ReadonlyArray<{
+    pickle: Pickle;
+    lineage: Lineage;
+}>): LineageConstraints;

package/dist/search/deriveLineageConstraints.js

@@ -0,0 +1,38 @@
+export function deriveLineageConstraints(items) {
+    const gherkinDocument = new Set();
+    const background = new Set();
+    const rule = new Set();
+    const scenario = new Set();
+    const examples = new Set();
+    const example = new Set();
+    for (const { pickle, lineage } of items) {
+        gherkinDocument.add(pickle.uri);
+        if (lineage.background) {
+            background.add(lineage.background.id);
+        }
+        if (lineage.ruleBackground) {
+            background.add(lineage.ruleBackground.id);
+        }
+        if (lineage.rule) {
+            rule.add(lineage.rule.id);
+        }
+        if (lineage.scenario) {
+            scenario.add(lineage.scenario.id);
+        }
+        if (lineage.examples) {
+            examples.add(lineage.examples.id);
+        }
+        if (lineage.example) {
+            example.add(lineage.example.id);
+        }
+    }
+    return {
+        gherkinDocument,
+        background,
+        rule,
+        scenario,
+        examples,
+        example,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVyaXZlTGluZWFnZUNvbnN0cmFpbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlYXJjaC9kZXJpdmVMaW5lYWdlQ29uc3RyYWludHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsTUFBTSxVQUFVLHdCQUF3QixDQUN0QyxLQUEwRDtJQUUxRCxNQUFNLGVBQWUsR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFBO0lBQ3pDLE1BQU0sVUFBVSxHQUFHLElBQUksR0FBRyxFQUFVLENBQUE7SUFDcEMsTUFBTSxJQUFJLEdBQUcsSUFBSSxHQUFHLEVBQVUsQ0FBQTtJQUM5QixNQUFNLFFBQVEsR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFBO0lBQ2xDLE1BQU0sUUFBUSxHQUFHLElBQUksR0FBRyxFQUFVLENBQUE7SUFDbEMsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLEVBQVUsQ0FBQTtJQUNqQyxLQUFLLE1BQU0sRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLElBQUksS0FBSyxFQUFFLENBQUM7UUFDeEMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDL0IsSUFBSSxPQUFPLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDdkIsVUFBVSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQyxDQUFBO1FBQ3ZDLENBQUM7UUFDRCxJQUFJLE9BQU8sQ0FBQyxjQUFjLEVBQUUsQ0FBQztZQUMzQixVQUFVLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsRUFBRSxDQUFDLENBQUE7UUFDM0MsQ0FBQztRQUNELElBQUksT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQTtRQUMzQixDQUFDO1FBQ0QsSUFBSSxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDckIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFBO1FBQ25DLENBQUM7UUFDRCxJQUFJLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNyQixRQUFRLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUE7UUFDbkMsQ0FBQztRQUNELElBQUksT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ3BCLE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQTtRQUNqQyxDQUFDO0lBQ0gsQ0FBQztJQUNELE9BQU87UUFDTCxlQUFlO1FBQ2YsVUFBVTtRQUNWLElBQUk7UUFDSixRQUFRO1FBQ1IsUUFBUTtRQUNSLE9BQU87S0FDUixDQUFBO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUGlja2xlIH0gZnJvbSAnQGN1Y3VtYmVyL21lc3NhZ2VzJ1xuaW1wb3J0IHR5cGUgeyBMaW5lYWdlIH0gZnJvbSAnQGN1Y3VtYmVyL3F1ZXJ5J1xuaW1wb3J0IHR5cGUgeyBMaW5lYWdlQ29uc3RyYWludHMgfSBmcm9tICcuL3R5cGVzLmpzJ1xuXG5leHBvcnQgZnVuY3Rpb24gZGVyaXZlTGluZWFnZUNvbnN0cmFpbnRzKFxuICBpdGVtczogUmVhZG9ubHlBcnJheTx7IHBpY2tsZTogUGlja2xlOyBsaW5lYWdlOiBMaW5lYWdlIH0+XG4pOiBMaW5lYWdlQ29uc3RyYWludHMge1xuICBjb25zdCBnaGVya2luRG9jdW1lbnQgPSBuZXcgU2V0PHN0cmluZz4oKVxuICBjb25zdCBiYWNrZ3JvdW5kID0gbmV3IFNldDxzdHJpbmc+KClcbiAgY29uc3QgcnVsZSA9IG5ldyBTZXQ8c3RyaW5nPigpXG4gIGNvbnN0IHNjZW5hcmlvID0gbmV3IFNldDxzdHJpbmc+KClcbiAgY29uc3QgZXhhbXBsZXMgPSBuZXcgU2V0PHN0cmluZz4oKVxuICBjb25zdCBleGFtcGxlID0gbmV3IFNldDxzdHJpbmc+KClcbiAgZm9yIChjb25zdCB7IHBpY2tsZSwgbGluZWFnZSB9IG9mIGl0ZW1zKSB7XG4gICAgZ2hlcmtpbkRvY3VtZW50LmFkZChwaWNrbGUudXJpKVxuICAgIGlmIChsaW5lYWdlLmJhY2tncm91bmQpIHtcbiAgICAgIGJhY2tncm91bmQuYWRkKGxpbmVhZ2UuYmFja2dyb3VuZC5pZClcbiAgICB9XG4gICAgaWYgKGxpbmVhZ2UucnVsZUJhY2tncm91bmQpIHtcbiAgICAgIGJhY2tncm91bmQuYWRkKGxpbmVhZ2UucnVsZUJhY2tncm91bmQuaWQpXG4gICAgfVxuICAgIGlmIChsaW5lYWdlLnJ1bGUpIHtcbiAgICAgIHJ1bGUuYWRkKGxpbmVhZ2UucnVsZS5pZClcbiAgICB9XG4gICAgaWYgKGxpbmVhZ2Uuc2NlbmFyaW8pIHtcbiAgICAgIHNjZW5hcmlvLmFkZChsaW5lYWdlLnNjZW5hcmlvLmlkKVxuICAgIH1cbiAgICBpZiAobGluZWFnZS5leGFtcGxlcykge1xuICAgICAgZXhhbXBsZXMuYWRkKGxpbmVhZ2UuZXhhbXBsZXMuaWQpXG4gICAgfVxuICAgIGlmIChsaW5lYWdlLmV4YW1wbGUpIHtcbiAgICAgIGV4YW1wbGUuYWRkKGxpbmVhZ2UuZXhhbXBsZS5pZClcbiAgICB9XG4gIH1cbiAgcmV0dXJuIHtcbiAgICBnaGVya2luRG9jdW1lbnQsXG4gICAgYmFja2dyb3VuZCxcbiAgICBydWxlLFxuICAgIHNjZW5hcmlvLFxuICAgIGV4YW1wbGVzLFxuICAgIGV4YW1wbGUsXG4gIH1cbn1cbiJdfQ==

package/dist/search/filterAndExpandTestCaseEvents.d.ts

@@ -0,0 +1,20 @@
+import { type Pickle, type TestCaseFinished, type TestCaseStarted, type TestStepResultStatus } from '@cucumber/messages';
+import type { Query as CucumberQuery, Lineage } from '@cucumber/query';
+import type { Node as TagExpression } from '@cucumber/tag-expressions';
+export interface ExpandedTestCase<T extends TestCaseStarted | TestCaseFinished> {
+    testCaseEvent: T;
+    pickle: Pickle;
+    lineage: Lineage;
+}
+export interface FilterCriteria {
+    hideStatuses: ReadonlyArray<TestStepResultStatus>;
+    tagExpression?: TagExpression;
+}
+/**
+ * Filters test cases by status and/or tag expression, expanding each survivor with its pickle and
+ * lineage.
+ *
+ * Works for either `TestCaseStarted` or `TestCaseFinished` - the element type flows through to the
+ * `testCaseEvent` of each returned item.
+ */
+export declare function filterAndExpandTestCaseEvents<T extends TestCaseStarted | TestCaseFinished>(cucumberQuery: CucumberQuery, testCaseEvents: ReadonlyArray<T>, { hideStatuses, tagExpression }: FilterCriteria): Array<ExpandedTestCase<T>>;

package/dist/search/filterAndExpandTestCaseEvents.js

@@ -0,0 +1,32 @@
+import { TestStepResultStatus as Status, } from '@cucumber/messages';
+import { ensure } from '../ensure.js';
+/**
+ * Filters test cases by status and/or tag expression, expanding each survivor with its pickle and
+ * lineage.
+ *
+ * Works for either `TestCaseStarted` or `TestCaseFinished` - the element type flows through to the
+ * `testCaseEvent` of each returned item.
+ */
+export function filterAndExpandTestCaseEvents(cucumberQuery, testCaseEvents, { hideStatuses, tagExpression }) {
+    const expanded = [];
+    for (const testCaseEvent of testCaseEvents) {
+        if (hideStatuses.length) {
+            const status = cucumberQuery.findMostSevereTestStepResultBy(testCaseEvent)?.status ?? Status.UNKNOWN;
+            if (hideStatuses.includes(status)) {
+                continue;
+            }
+        }
+        const id = 'id' in testCaseEvent ? testCaseEvent.id : testCaseEvent.testCaseStartedId;
+        const pickle = ensure(cucumberQuery.findPickleBy(testCaseEvent), `No Pickle found for TestCase ${id}`);
+        if (tagExpression) {
+            const tags = pickle.tags.map((tag) => tag.name);
+            if (!tagExpression.evaluate(tags)) {
+                continue;
+            }
+        }
+        const lineage = ensure(cucumberQuery.findLineageBy(pickle), `No Lineage found for Pickle ${pickle.uri}`);
+        expanded.push({ testCaseEvent, pickle, lineage });
+    }
+    return expanded;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/search/index.d.ts

@@ -0,0 +1,6 @@
+export * from './createSearchIndex.js';
+export * from './deriveLineageConstraints.js';
+export * from './filterAndExpandTestCaseEvents.js';
+export * from './pruneGherkinDocuments.js';
+export * from './pruneTestCaseEvents.js';
+export * from './types.js';

package/dist/search/index.js

@@ -0,0 +1,7 @@
+export * from './createSearchIndex.js';
+export * from './deriveLineageConstraints.js';
+export * from './filterAndExpandTestCaseEvents.js';
+export * from './pruneGherkinDocuments.js';
+export * from './pruneTestCaseEvents.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VhcmNoL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYywrQkFBK0IsQ0FBQTtBQUM3QyxjQUFjLG9DQUFvQyxDQUFBO0FBQ2xELGNBQWMsNEJBQTRCLENBQUE7QUFDMUMsY0FBYywwQkFBMEIsQ0FBQTtBQUN4QyxjQUFjLFlBQVksQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY3JlYXRlU2VhcmNoSW5kZXguanMnXG5leHBvcnQgKiBmcm9tICcuL2Rlcml2ZUxpbmVhZ2VDb25zdHJhaW50cy5qcydcbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyQW5kRXhwYW5kVGVzdENhc2VFdmVudHMuanMnXG5leHBvcnQgKiBmcm9tICcuL3BydW5lR2hlcmtpbkRvY3VtZW50cy5qcydcbmV4cG9ydCAqIGZyb20gJy4vcHJ1bmVUZXN0Q2FzZUV2ZW50cy5qcydcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMuanMnXG4iXX0=

package/dist/search/pruneGherkinDocuments.d.ts

@@ -0,0 +1,23 @@
+import type { GherkinDocument } from '@cucumber/messages';
+import type { LineageConstraints, SearchHits } from './types.js';
+/**
+ * Returns abridged copies of the given documents, with lineage constraints and search hits used
+ * to filter out nodes that shouldn't be shown
+ *
+ * @param gherkinDocuments - the original documents to prune
+ * @param constraints - the set of AST node IDs to retain, derived from pickle lineage
+ * @param searchHits - if provided, further narrows results to nodes matching a search query
+ *
+ * @remarks
+ * The two filtering mechanisms behave a little differently.
+ *
+ * `lineageConstraints` are strictly enforced at every level - any node of the covered types must
+ * have its id included otherwise it will be filtered off. This check is performed eagerly at every
+ * level so for e.g. a Rule that isn't matched, we won't even look at its child Scenarios.
+ *
+ * `searchHits` has cascading behaviour - a match at a higher level (Feature, Rule, or Background)
+ * ensures all of its descendants will be retained, and a match at a lower level (Scenario, Step)
+ * ensures all of its ascendants (but not siblings) will be retained. An empty map means there were
+ * no hits at all, so no documents will be returned.
+ */
+export declare function pruneGherkinDocuments(gherkinDocuments: ReadonlyArray<GherkinDocument>, constraints: LineageConstraints, searchHits?: SearchHits): ReadonlyArray<GherkinDocument>;