@eagleoutice/flowr 2.1.11 → 2.1.12

package/search/flowr-search-builder.d.ts

@@ -0,0 +1,193 @@
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchGetFilter } from './flowr-search';
+import type { FlowrFilterExpression } from './flowr-search-filters';
+import type { FlowrSearchGeneratorNode, GeneratorNames } from './search-executor/search-generators';
+import type { FlowrSearchTransformerNode, GetOutputOfTransformer, TransformerNames } from './search-executor/search-transformer';
+import type { SlicingCriteria } from '../slicing/criterion/parse';
+import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+type FlowrCriteriaReturn<C extends SlicingCriteria> = FlowrSearchElements<ParentInformation, C extends [] ? never : C extends [infer _] ? [
+    FlowrSearchElement<ParentInformation>
+] : FlowrSearchElement<ParentInformation>[]>;
+/**
+ * This object holds all the methods to generate search queries.
+ * For compatibility, please use the {@link Q} identifier object to access these methods.
+ */
+export declare const FlowrSearchGenerator: {
+    /**
+     * Initialize a search query with the given elements.
+     * <b>This is not intended to serialize well</b> wrt. the nodes,
+     * see {@link FlowrSearchGenerator.criterion} for a serializable alternative (passing the ids with `$id`).
+     */
+    readonly from: (from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[]) => FlowrSearchBuilder<"from">;
+    /**
+     * Returns all elements (nodes/dataflow vertices) from the given data.
+     */
+    readonly all: () => FlowrSearchBuilder<"all">;
+    /**
+     * Returns all elements that match the given {@link FlowrSearchGetFilters|filters}.
+     * You may pass a negative line number to count from the back.
+     * Please note that this is currently only working for single files, it approximates over the nodes, and it is not to be used for "production".
+     */
+    readonly get: (filter: FlowrSearchGetFilter) => FlowrSearchBuilder<"get">;
+    /**
+     * Returns all elements that match the given {@link SlicingCriteria|criteria}
+     * (e.g., `criterion('2@x', '3@<-')`,
+     * to retrieve the first use of `x` in the second line and the first `<-` assignment in the third line).
+     * This will throw an error, if any criteria cannot be resolved to an id.
+     */
+    readonly criterion: <Criteria extends SlicingCriteria>(...criterion: Criteria) => FlowrSearchBuilder<"criterion", [], ParentInformation, FlowrCriteriaReturn<Criteria>>;
+    /**
+     * Short form of {@link get} with only the
+     * {@link FlowrSearchGetFilters#line|line} and {@link FlowrSearchGetFilters#column|column} filters:
+     * `get({line, column})`.
+     */
+    readonly loc: (line?: number, column?: number) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} and {@link FlowrSearchGetFilters#line|line} filters:
+     * `get({name, line})`.
+     */
+    readonly varInLine: (name: string, line: number) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} filter:
+     * `get({name})`.
+     */
+    readonly var: (name: string) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#id|id} filter:
+     * `get({id})`.
+     */
+    readonly id: (id: NodeId) => FlowrSearchBuilder<"get">;
+};
+/**
+ * This is the root object to use for creating searches.
+ * See the {@link FlowrSearchGenerator} for the available methods.
+ * After the query is generated,
+ * you can use what is provided by the {@link FlowrSearchBuilder} to further refine the search.
+ */
+export declare const Q: {
+    /**
+     * Initialize a search query with the given elements.
+     * <b>This is not intended to serialize well</b> wrt. the nodes,
+     * see {@link FlowrSearchGenerator.criterion} for a serializable alternative (passing the ids with `$id`).
+     */
+    readonly from: (from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[]) => FlowrSearchBuilder<"from">;
+    /**
+     * Returns all elements (nodes/dataflow vertices) from the given data.
+     */
+    readonly all: () => FlowrSearchBuilder<"all">;
+    /**
+     * Returns all elements that match the given {@link FlowrSearchGetFilters|filters}.
+     * You may pass a negative line number to count from the back.
+     * Please note that this is currently only working for single files, it approximates over the nodes, and it is not to be used for "production".
+     */
+    readonly get: (filter: FlowrSearchGetFilter) => FlowrSearchBuilder<"get">;
+    /**
+     * Returns all elements that match the given {@link SlicingCriteria|criteria}
+     * (e.g., `criterion('2@x', '3@<-')`,
+     * to retrieve the first use of `x` in the second line and the first `<-` assignment in the third line).
+     * This will throw an error, if any criteria cannot be resolved to an id.
+     */
+    readonly criterion: <Criteria extends SlicingCriteria>(...criterion: Criteria) => FlowrSearchBuilder<"criterion", [], ParentInformation, FlowrCriteriaReturn<Criteria>>;
+    /**
+     * Short form of {@link get} with only the
+     * {@link FlowrSearchGetFilters#line|line} and {@link FlowrSearchGetFilters#column|column} filters:
+     * `get({line, column})`.
+     */
+    readonly loc: (line?: number, column?: number) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} and {@link FlowrSearchGetFilters#line|line} filters:
+     * `get({name, line})`.
+     */
+    readonly varInLine: (name: string, line: number) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} filter:
+     * `get({name})`.
+     */
+    readonly var: (name: string) => FlowrSearchBuilder<"get">;
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#id|id} filter:
+     * `get({id})`.
+     */
+    readonly id: (id: NodeId) => FlowrSearchBuilder<"get">;
+};
+export type FlowrSearchBuilderType<Generator extends GeneratorNames = GeneratorNames, Transformers extends TransformerNames[] = TransformerNames[], Info = ParentInformation, ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> = FlowrSearchBuilder<Generator, Transformers, Info, ElementType>;
+type GetElements<F> = F extends FlowrSearchElements<infer Info, infer Elements> ? Elements extends FlowrSearchElement<Info>[] ? Elements : never : never;
+/**
+ * The search query is a combination of a generator and a list of transformers
+ * and allows this view to pass such queries in a serialized form.
+ *
+ * @typeParam Transformers - The list of transformers that are applied to the generator's output.
+ */
+export interface FlowrSearch<Info = ParentInformation, _Generator extends GeneratorNames = GeneratorNames, _Transformers extends readonly TransformerNames[] = readonly TransformerNames[], _ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> {
+    readonly generator: FlowrSearchGeneratorNode;
+    readonly search: readonly FlowrSearchTransformerNode[];
+}
+type FlowrSearchBuilderOut<Generator extends GeneratorNames, Transformers extends TransformerNames[], Info, Transformer extends TransformerNames> = FlowrSearchBuilder<Generator, [...Transformers, Transformer], Info, GetOutputOfTransformer<Transformer>>;
+/**
+ * Allows you to construct a search query from a {@link FlowrSearchGeneratorNode}.
+ * Please use the {@link Q} object to create an object of this class!
+ * In the end, you _can_ freeze the search by calling {@link FlowrSearchBuilder#build},
+ * however, the search executors may do that for you.
+ *
+ * @see {@link FlowrSearchGenerator}
+ * @see {@link FlowrSearch}
+ * @see {@link FlowrSearchLike}
+ */
+export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transformers extends TransformerNames[] = [], Info = ParentInformation, ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> {
+    private readonly generator;
+    private readonly search;
+    constructor(generator: FlowrSearchGeneratorNode);
+    /**
+     * only returns the elements that match the given filter.
+     */
+    filter(filter: FlowrFilterExpression): FlowrSearchBuilderOut<Generator, Transformers, Info, 'filter'>;
+    /**
+     * first either returns the first element of the search or nothing, if no elements are present.
+     */
+    first(): FlowrSearchBuilderOut<Generator, Transformers, Info, 'first'>;
+    /**
+     * last either returns the last element of the search or nothing, if no elements are present.
+     */
+    last(): FlowrSearchBuilderOut<Generator, Transformers, Info, 'last'>;
+    /**
+     * index returns the element at the given index if it exists
+     */
+    index<Idx extends number>(index: Idx): FlowrSearchBuilderOut<Generator, Transformers, Info, 'index'>;
+    /**
+     * tail returns all elements of the search except the first one.
+     */
+    tail(): FlowrSearchBuilderOut<Generator, Transformers, Info, 'tail'>;
+    /**
+     * take returns the first `count` elements of the search.
+     */
+    take<Count extends number>(count: Count): FlowrSearchBuilderOut<Generator, Transformers, Info, 'take'>;
+    /**
+     * skip returns all elements of the search except the first `count` ones.
+     */
+    skip<Count extends number>(count: Count): FlowrSearchBuilderOut<Generator, Transformers, Info, 'skip'>;
+    /**
+     * select returns only the elements at the given indices.
+     */
+    select<Select extends number[]>(...select: Select): FlowrSearchBuilderOut<Generator, Transformers, Info, 'select'>;
+    /**
+     * merge combines the search results with those of another search.
+     */
+    merge<Generator2 extends GeneratorNames, Transformers2 extends TransformerNames[], OtherElementType extends FlowrSearchElements<Info, FlowrSearchElement<Info>[]>>(other: FlowrSearchBuilder<Generator2, Transformers2, Info, OtherElementType>): FlowrSearchBuilder<Generator, Transformers, Info, FlowrSearchElements<Info, [...GetElements<ElementType>, ...GetElements<OtherElementType>]>>;
+    /**
+     * Construct the final search (this may happen automatically with most search handlers).
+     *
+     * @param shouldOptimize - This may optimize the search.
+     */
+    build(shouldOptimize?: boolean): FlowrSearch<Info, Generator, Transformers, ElementType>;
+}
+/**
+ * This type summarizes all types that can be used in places in which the API expects you to provide a search query.
+ * @see {@link FlowrSearch}
+ */
+export type FlowrSearchLike = FlowrSearch | FlowrSearchBuilderType;
+export type SearchOutput<Search> = Search extends FlowrSearch ? Search : Search extends FlowrSearchBuilderType<infer Generator, infer Transformers, infer Info, infer Elements> ? FlowrSearch<Info, Generator, Transformers, Elements> : never;
+/**
+ * Freezes any accepted {@link FlowrSearchLike} into a {@link FlowrSearch}.
+ */
+export declare function getFlowrSearch<Search extends FlowrSearchLike>(search: Search, optimizeIfBuild?: boolean): SearchOutput<Search>;
+export {};

package/search/flowr-search-builder.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrSearchBuilder = exports.Q = exports.FlowrSearchGenerator = void 0;
+exports.getFlowrSearch = getFlowrSearch;
+const search_optimizer_1 = require("./search-optimizer/search-optimizer");
+const assert_1 = require("../util/assert");
+/**
+ * This object holds all the methods to generate search queries.
+ * For compatibility, please use the {@link Q} identifier object to access these methods.
+ */
+exports.FlowrSearchGenerator = {
+    /**
+     * Initialize a search query with the given elements.
+     * <b>This is not intended to serialize well</b> wrt. the nodes,
+     * see {@link FlowrSearchGenerator.criterion} for a serializable alternative (passing the ids with `$id`).
+     */
+    from(from) {
+        return new FlowrSearchBuilder({ type: 'generator', name: 'from', args: { from } });
+    },
+    /**
+     * Returns all elements (nodes/dataflow vertices) from the given data.
+     */
+    all() {
+        return new FlowrSearchBuilder({ type: 'generator', name: 'all', args: undefined });
+    },
+    /**
+     * Returns all elements that match the given {@link FlowrSearchGetFilters|filters}.
+     * You may pass a negative line number to count from the back.
+     * Please note that this is currently only working for single files, it approximates over the nodes, and it is not to be used for "production".
+     */
+    get(filter) {
+        (0, assert_1.guard)(!filter.nameIsRegex || filter.name, 'If nameIsRegex is set, a name should be provided');
+        (0, assert_1.guard)(!filter.line || filter.line != 0, 'If line is set, it must be different from 0 as there is no 0 line');
+        (0, assert_1.guard)(!filter.column || filter.column > 0, 'If column is set, it must be greater than 0, but was ' + filter.column);
+        return new FlowrSearchBuilder({ type: 'generator', name: 'get', args: { filter } });
+    },
+    /**
+     * Returns all elements that match the given {@link SlicingCriteria|criteria}
+     * (e.g., `criterion('2@x', '3@<-')`,
+     * to retrieve the first use of `x` in the second line and the first `<-` assignment in the third line).
+     * This will throw an error, if any criteria cannot be resolved to an id.
+     */
+    criterion(...criterion) {
+        (0, assert_1.guard)(criterion.length > 0, 'At least one criterion must be provided');
+        return new FlowrSearchBuilder({ type: 'generator', name: 'criterion', args: { criterion } });
+    },
+    /**
+     * Short form of {@link get} with only the
+     * {@link FlowrSearchGetFilters#line|line} and {@link FlowrSearchGetFilters#column|column} filters:
+     * `get({line, column})`.
+     */
+    loc(line, column) {
+        return exports.FlowrSearchGenerator.get({ line, column });
+    },
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} and {@link FlowrSearchGetFilters#line|line} filters:
+     * `get({name, line})`.
+     */
+    varInLine(name, line) {
+        return exports.FlowrSearchGenerator.get({ name, line });
+    },
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#name|name} filter:
+     * `get({name})`.
+     */
+    var(name) {
+        return exports.FlowrSearchGenerator.get({ name });
+    },
+    /**
+     * Short form of {@link get} with only the {@link FlowrSearchGetFilters#id|id} filter:
+     * `get({id})`.
+     */
+    id(id) {
+        return exports.FlowrSearchGenerator.get({ id });
+    }
+};
+/**
+ * This is the root object to use for creating searches.
+ * See the {@link FlowrSearchGenerator} for the available methods.
+ * After the query is generated,
+ * you can use what is provided by the {@link FlowrSearchBuilder} to further refine the search.
+ */
+exports.Q = exports.FlowrSearchGenerator;
+/**
+ * Allows you to construct a search query from a {@link FlowrSearchGeneratorNode}.
+ * Please use the {@link Q} object to create an object of this class!
+ * In the end, you _can_ freeze the search by calling {@link FlowrSearchBuilder#build},
+ * however, the search executors may do that for you.
+ *
+ * @see {@link FlowrSearchGenerator}
+ * @see {@link FlowrSearch}
+ * @see {@link FlowrSearchLike}
+ */
+class FlowrSearchBuilder {
+    generator;
+    search = [];
+    constructor(generator) {
+        this.generator = generator;
+    }
+    /**
+     * only returns the elements that match the given filter.
+     */
+    filter(filter) {
+        this.search.push({ type: 'transformer', name: 'filter', args: { filter: filter } });
+        return this;
+    }
+    /**
+     * first either returns the first element of the search or nothing, if no elements are present.
+     */
+    first() {
+        this.search.push({ type: 'transformer', name: 'first', args: undefined });
+        return this;
+    }
+    /**
+     * last either returns the last element of the search or nothing, if no elements are present.
+     */
+    last() {
+        this.search.push({ type: 'transformer', name: 'last', args: undefined });
+        return this;
+    }
+    /**
+     * index returns the element at the given index if it exists
+     */
+    index(index) {
+        (0, assert_1.guard)(index >= 0, 'Index must be greater or equal to 0, but was ' + index);
+        this.search.push({ type: 'transformer', name: 'index', args: { index } });
+        return this;
+    }
+    /**
+     * tail returns all elements of the search except the first one.
+     */
+    tail() {
+        this.search.push({ type: 'transformer', name: 'tail', args: undefined });
+        return this;
+    }
+    /**
+     * take returns the first `count` elements of the search.
+     */
+    take(count) {
+        (0, assert_1.guard)(count >= 0, 'Count must be greater or equal to 0, but was ' + count);
+        this.search.push({ type: 'transformer', name: 'take', args: { count } });
+        return this;
+    }
+    /**
+     * skip returns all elements of the search except the first `count` ones.
+     */
+    skip(count) {
+        (0, assert_1.guard)(count >= 0, 'Count must be greater or equal to 0, but was ' + count);
+        this.search.push({ type: 'transformer', name: 'skip', args: { count } });
+        return this;
+    }
+    /**
+     * select returns only the elements at the given indices.
+     */
+    select(...select) {
+        (0, assert_1.guard)(select.length > 0, 'At least one index must be provided');
+        (0, assert_1.guard)(select.every(i => i >= 0), () => 'All indices must be greater or equal to 0, but were ' + JSON.stringify(select));
+        this.search.push({ type: 'transformer', name: 'select', args: { select } });
+        return this;
+    }
+    /**
+     * merge combines the search results with those of another search.
+     */
+    merge(other /* | FlowrSearch<Info, Generator2, Transformers2, OtherElementType> */
+    // @ts-expect-error -- this works when merging, there is no info disparity
+    ) {
+        this.search.push({ type: 'transformer', name: 'merge', args: { generator: other.generator, search: other.search } });
+        return this;
+    }
+    /**
+     * Construct the final search (this may happen automatically with most search handlers).
+     *
+     * @param shouldOptimize - This may optimize the search.
+     */
+    build(shouldOptimize = true) {
+        return shouldOptimize ? (0, search_optimizer_1.optimize)(this.generator, this.search) : {
+            generator: this.generator,
+            search: this.search
+        };
+    }
+}
+exports.FlowrSearchBuilder = FlowrSearchBuilder;
+/**
+ * Freezes any accepted {@link FlowrSearchLike} into a {@link FlowrSearch}.
+ */
+function getFlowrSearch(search, optimizeIfBuild = true) {
+    if (search instanceof FlowrSearchBuilder) {
+        return search.build(optimizeIfBuild);
+    }
+    return search;
+}
+//# sourceMappingURL=flowr-search-builder.js.map

package/search/flowr-search-executor.d.ts

@@ -0,0 +1,9 @@
+import type { FlowrSearch, FlowrSearchLike, SearchOutput } from './flowr-search-builder';
+import type { FlowrSearchElements, FlowrSearchInput } from './flowr-search';
+import type { Pipeline } from '../core/steps/pipeline/pipeline';
+type GetSearchElements<S> = S extends FlowrSearch<infer _, infer _, infer _, infer Elements> ? Elements extends FlowrSearchElements<infer _, infer E> ? E : never : never;
+/**
+ * Run a search with the given search query and data.
+ */
+export declare function runSearch<S extends FlowrSearchLike, P extends Pipeline>(search: S, data: FlowrSearchInput<P>): GetSearchElements<SearchOutput<S>>;
+export {};

package/search/flowr-search-executor.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSearch = runSearch;
+const flowr_search_builder_1 = require("./flowr-search-builder");
+const search_generators_1 = require("./search-executor/search-generators");
+const search_transformer_1 = require("./search-executor/search-transformer");
+/**
+ * Run a search with the given search query and data.
+ */
+function runSearch(search, data) {
+    const s = (0, flowr_search_builder_1.getFlowrSearch)(search);
+    return s.search.reduce((acc, transformer) => (0, search_transformer_1.getTransformer)(transformer.name)(data, acc, transformer.args), 
+    /* support multiple arguments may be abstracted away in search frontend */
+    (0, search_generators_1.getGenerator)(s.generator.name)(data, s.generator.args)).getElements();
+}
+//# sourceMappingURL=flowr-search-executor.js.map

package/search/flowr-search-filters.d.ts

@@ -0,0 +1,74 @@
+import { RType } from '../r-bridge/lang-4.x/ast/model/type';
+import type { VertexType } from '../dataflow/graph/vertex';
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowInformation } from '../dataflow/info';
+import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
+export type FlowrFilterName = keyof typeof FlowrFilters;
+export declare enum FlowrFilter {
+    DropEmptyArguments = "drop-empty-arguments"
+}
+export declare const ValidFlowrFilters: Set<string>;
+export declare const ValidFlowrFiltersReverse: {
+    [k: string]: string;
+};
+export declare const FlowrFilters: {
+    readonly "drop-empty-arguments": (n: RNode<ParentInformation>) => boolean;
+};
+type ValidFilterTypes = FlowrFilterName | RType | VertexType;
+/**
+ * By default, we provide filter for every {@link RType} and {@link VertexType}.
+ */
+export type FlowrFilterExpression = FlowrFilterCombinator | ValidFilterTypes;
+interface BooleanBinaryNode<Composite> {
+    readonly type: 'and' | 'or' | 'xor';
+    readonly left: Composite;
+    readonly right: Composite;
+}
+interface BooleanUnaryNode<Composite> {
+    readonly type: 'not';
+    readonly operand: Composite;
+}
+type LeafRType = {
+    readonly type: 'r-type';
+    readonly value: RType;
+};
+type LeafVertexType = {
+    readonly type: 'vertex-type';
+    readonly value: VertexType;
+};
+type LeafSpecial = {
+    readonly type: 'special';
+    readonly value: string;
+};
+type Leaf = LeafRType | LeafVertexType | LeafSpecial;
+type BooleanNode = BooleanBinaryNode<BooleanNode> | BooleanUnaryNode<BooleanNode> | Leaf;
+type BooleanNodeOrCombinator = BooleanNode | FlowrFilterCombinator;
+/**
+ * @see {@link FlowrFilterCombinator.is}
+ * @see {@link evalFilter}
+ * @see {@link binaryTreeToString}
+ */
+export declare class FlowrFilterCombinator {
+    private tree;
+    protected constructor(init: BooleanNodeOrCombinator);
+    static is(value: BooleanNodeOrCombinator | ValidFilterTypes): FlowrFilterCombinator;
+    and(right: BooleanNodeOrCombinator | ValidFilterTypes): this;
+    or(right: BooleanNodeOrCombinator | ValidFilterTypes): this;
+    xor(right: BooleanNodeOrCombinator | ValidFilterTypes): this;
+    private binaryRight;
+    not(): this;
+    private unary;
+    private unpack;
+    get(): BooleanNode;
+}
+export declare function binaryTreeToString(tree: BooleanNode): string;
+export declare function isBinaryTree(tree: unknown): tree is {
+    tree: BooleanNode;
+};
+interface FilterData {
+    readonly node: RNode<ParentInformation>;
+    readonly normalize: NormalizedAst;
+    readonly dataflow: DataflowInformation;
+}
+export declare function evalFilter(filter: FlowrFilterExpression, data: FilterData): boolean;
+export {};

package/search/flowr-search-filters.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrFilterCombinator = exports.FlowrFilters = exports.ValidFlowrFiltersReverse = exports.ValidFlowrFilters = exports.FlowrFilter = void 0;
+exports.binaryTreeToString = binaryTreeToString;
+exports.isBinaryTree = isBinaryTree;
+exports.evalFilter = evalFilter;
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+const vertex_1 = require("../dataflow/graph/vertex");
+var FlowrFilter;
+(function (FlowrFilter) {
+    FlowrFilter["DropEmptyArguments"] = "drop-empty-arguments";
+})(FlowrFilter || (exports.FlowrFilter = FlowrFilter = {}));
+exports.ValidFlowrFilters = new Set(Object.values(FlowrFilter));
+exports.ValidFlowrFiltersReverse = Object.fromEntries(Object.entries(FlowrFilter).map(([k, v]) => [v, k]));
+exports.FlowrFilters = {
+    [FlowrFilter.DropEmptyArguments]: (n) => {
+        return n.type !== type_1.RType.Argument || n.name !== undefined;
+    }
+};
+/**
+ * @see {@link FlowrFilterCombinator.is}
+ * @see {@link evalFilter}
+ * @see {@link binaryTreeToString}
+ */
+class FlowrFilterCombinator {
+    tree;
+    constructor(init) {
+        this.tree = this.unpack(init);
+    }
+    static is(value) {
+        if (typeof value === 'object') {
+            return new this(value);
+        }
+        else if (type_1.ValidRTypes.has(value)) {
+            return new this({ type: 'r-type', value: value });
+        }
+        else if (vertex_1.ValidVertexTypes.has(value)) {
+            return new this({ type: 'vertex-type', value: value });
+        }
+        else if (exports.ValidFlowrFilters.has(value)) {
+            return new this({ type: 'special', value: value });
+        }
+        else {
+            throw new Error(`Invalid filter value: ${value}`);
+        }
+    }
+    and(right) {
+        return this.binaryRight('and', right);
+    }
+    or(right) {
+        return this.binaryRight('or', right);
+    }
+    xor(right) {
+        return this.binaryRight('xor', right);
+    }
+    binaryRight(op, right) {
+        this.tree = {
+            type: op,
+            left: this.tree,
+            right: this.unpack(FlowrFilterCombinator.is(right))
+        };
+        return this;
+    }
+    not() {
+        return this.unary('not');
+    }
+    unary(op) {
+        this.tree = {
+            type: op,
+            operand: this.tree
+        };
+        return this;
+    }
+    unpack(val) {
+        return val instanceof FlowrFilterCombinator ? val.tree : val;
+    }
+    get() {
+        return this.tree;
+    }
+}
+exports.FlowrFilterCombinator = FlowrFilterCombinator;
+function binaryTreeToString(tree) {
+    const res = treeToStringImpl(tree, 0);
+    // drop outer parens
+    if (res.startsWith('(') && res.endsWith(')')) {
+        return res.slice(1, -1);
+    }
+    else {
+        return res;
+    }
+}
+const typeToSymbol = {
+    'and': '∧',
+    'or': '∨',
+    'xor': '⊕',
+    'not': '¬'
+};
+function treeToStringImpl(tree, depth) {
+    if (tree.type === 'r-type' || tree.type === 'vertex-type' || tree.type === 'special') {
+        return tree.value;
+    }
+    if (tree.type === 'not') {
+        return `${typeToSymbol[tree.type]}${treeToStringImpl(tree.operand, depth)}`;
+    }
+    const left = treeToStringImpl(tree.left, depth + 1);
+    const right = treeToStringImpl(tree.right, depth + 1);
+    return `(${left} ${typeToSymbol[tree.type]} ${right})`;
+}
+function isBinaryTree(tree) {
+    return typeof tree === 'object' && tree !== null && 'tree' in tree;
+}
+const evalVisit = {
+    and: ({ left, right }, data) => evalTree(left, data) && evalTree(right, data),
+    or: ({ left, right }, data) => evalTree(left, data) || evalTree(right, data),
+    xor: ({ left, right }, data) => evalTree(left, data) !== evalTree(right, data),
+    not: ({ operand }, data) => !evalTree(operand, data),
+    'r-type': ({ value }, { node }) => node.type === value,
+    'vertex-type': ({ value }, { dataflow: { graph }, node }) => graph.getVertex(node.info.id)?.tag === value,
+    'special': ({ value }, { node }) => {
+        const getHandler = exports.FlowrFilters[value];
+        if (getHandler) {
+            return getHandler(node);
+        }
+        throw new Error(`Special filter not implemented: ${value}`);
+    }
+};
+function evalTree(tree, data) {
+    /* we ensure that the types fit */
+    return evalVisit[tree.type](tree, data);
+}
+function evalFilter(filter, data) {
+    /* common lift, this can be improved easily :D */
+    const tree = FlowrFilterCombinator.is(filter);
+    return evalTree(tree.get(), data);
+}
+//# sourceMappingURL=flowr-search-filters.js.map

package/search/flowr-search-printer.d.ts

@@ -0,0 +1,10 @@
+import type { FlowrSearchLike } from './flowr-search-builder';
+export interface FlowrSearchMermaidBuilderOptions {
+    header?: string;
+}
+/**
+ * Converts a {@link FlowrSearchLike} object to a mermaid flowchart.
+ */
+export declare function flowrSearchToMermaid(search: FlowrSearchLike, conf?: FlowrSearchMermaidBuilderOptions): string;
+export declare function flowrSearchToAscii(search: FlowrSearchLike): string;
+export declare function flowrSearchToCode(search: FlowrSearchLike): string;