@eagleoutice/flowr 2.4.7 → 2.4.8

package/queries/query.d.ts

@@ -26,6 +26,7 @@ import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ControlFlowQuery } from './catalog/control-flow-query/control-flow-query-format';
 import type { DfShapeQuery } from './catalog/df-shape-query/df-shape-query-format';
 import type { AsyncOrSync, AsyncOrSyncType } from 'ts-essentials';
+import type { FlowrConfigOptions } from '../config';
 /**
  * These are all queries that can be executed from within flowR
  * {@link SynchronousQuery} are queries that can be executed synchronously, i.e., they do not return a Promise.
@@ -42,15 +43,19 @@ export type QueryExecutor<Query extends BaseQueryFormat, Result extends BaseQuer
 type SupportedQueries = {
     [QueryType in Query['type']]: SupportedQuery<QueryType>;
 };
-export interface SupportedQuery<QueryType extends BaseQueryFormat['type']> {
+export interface SupportedQuery<QueryType extends BaseQueryFormat['type'] = BaseQueryFormat['type']> {
     executor: QueryExecutor<QueryArgumentsWithType<QueryType>, BaseQueryResult>;
-    asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, resultStrings: string[]) => boolean;
+    /** optional completion in, e.g., the repl */
+    completer?: (splitLine: readonly string[], config: FlowrConfigOptions) => string[];
+    /** optional query construction from an, e.g., repl line */
+    fromLine?: (splitLine: readonly string[], config: FlowrConfigOptions) => Query | Query[] | undefined;
+    asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, resultStrings: string[], query: readonly Query[]) => boolean;
     schema: Joi.ObjectSchema;
     /**
      * Flattens the involved query nodes to be added to a flowR search when the {@link fromQuery} function is used based on the given result after this query is executed.
      * If this query does not involve any nodes, an empty array can be returned.
      */
-    flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    flattenInvolvedNodes: (queryResults: BaseQueryResult, query: readonly Query[]) => NodeId[];
 }
 export declare const SupportedQueries: {
     readonly 'call-context': {
@@ -62,6 +67,8 @@ export declare const SupportedQueries: {
     readonly config: {
         readonly executor: typeof import("./catalog/config-query/config-query-executor").executeConfigQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+        readonly completer: (partialLine: readonly string[], config: FlowrConfigOptions) => string[];
+        readonly fromLine: (line: readonly string[], _config: FlowrConfigOptions) => [ConfigQuery];
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
@@ -107,7 +114,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -166,7 +173,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -225,7 +232,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -284,7 +291,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -343,7 +350,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -402,7 +409,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -461,7 +468,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -520,7 +527,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -579,7 +586,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -638,7 +645,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -651,9 +658,9 @@ export declare const SupportedQueries: {
                 readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
             };
             readonly dependencies: readonly ["normalize"];
-        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        }>>, queryResults: BaseQueryResult, result: string[], queries: readonly Query[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
-        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult, query: readonly Query[]) => NodeId[];
     };
     readonly 'location-map': {
         readonly executor: typeof import("./catalog/location-map-query/location-map-query-executor").executeLocationMapQuery;
@@ -703,7 +710,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -762,7 +769,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -821,7 +828,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -880,7 +887,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -939,7 +946,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";
@@ -998,7 +1005,7 @@ export declare const SupportedQueries: {
             }, input: {
                 request?: import("../r-bridge/retriever").RParseRequests;
                 parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
-            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            }, config: FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
             readonly requiredInput: {};
             readonly name: "dataflow";
             readonly description: "Construct the dataflow graph";

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

@@ -196,7 +196,7 @@ export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transf
     /**
      * A convenience function that combines {@link with} and the {@link Mapper.Enrichment} mapper to immediately add an enrichment and then map to its value(s).
      */
-    get<ConcreteEnrichment extends Enrichment>(enrichment: ConcreteEnrichment, args?: EnrichmentElementArguments<ConcreteEnrichment>): FlowrSearchBuilderOut<Generator, Transformers, Info, 'with' | 'map'>;
+    to<ConcreteEnrichment extends Enrichment>(enrichment: ConcreteEnrichment, args?: EnrichmentElementArguments<ConcreteEnrichment>): FlowrSearchBuilderOut<Generator, Transformers, Info, 'with' | 'map'>;
     /**
      * merge combines the search results with those of another search.
      */

package/search/flowr-search-builder.js

@@ -185,7 +185,7 @@ class FlowrSearchBuilder {
     /**
      * A convenience function that combines {@link with} and the {@link Mapper.Enrichment} mapper to immediately add an enrichment and then map to its value(s).
      */
-    get(enrichment, args) {
+    to(enrichment, args) {
         return this.with(enrichment, args).map(search_mappers_1.Mapper.Enrichment, enrichment);
     }
     /**

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

@@ -1,10 +1,10 @@
 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 { FlowrSearchElement } from './flowr-search';
-import type { MergeableRecord } from '../util/objects';
+import { VertexType } from '../dataflow/graph/vertex';
+import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { FlowrSearchElement, FlowrSearchInput } from './flowr-search';
 import type { Enrichment } from './search-executor/search-enrichers';
+import type { BuiltInMappingName } from '../dataflow/environments/built-in';
+import type { Pipeline } from '../core/steps/pipeline/pipeline';
 export type FlowrFilterName = keyof typeof FlowrFilters;
 interface FlowrFilterWithArgs<Filter extends FlowrFilterName, Args extends FlowrFilterArgs<Filter>> {
     name: Filter;
@@ -21,9 +21,14 @@ export declare enum FlowrFilter {
      * This filter accepts {@link MatchesEnrichmentArgs}, which includes the enrichment to match for, as well as the regular expression to test the enrichment's (non-pretty-printed) JSON representation for.
      * To test for included function names in an enrichment like {@link Enrichment.CallTargets}, the helper function {@link testFunctionsIgnoringPackage} can be used.
      */
-    MatchesEnrichment = "matches-enrichment"
+    MatchesEnrichment = "matches-enrichment",
+    /**
+     * Only returns search elements whose {@link FunctionOriginInformation} match a given pattern or value.
+     * This filter accepts {@link OriginKindArgs}, which includes the {@link DataflowGraphVertexFunctionCall.origin} to match for, whether to match for every or some origins, and whether to include non-function-calls in the filtered query.
+     */
+    OriginKind = "origin-kind"
 }
-export type FlowrFilterFunction<T extends MergeableRecord> = (e: FlowrSearchElement<ParentInformation>, args: T) => boolean;
+export type FlowrFilterFunction<T> = (e: FlowrSearchElement<ParentInformation>, args: T, data: FlowrSearchInput<Pipeline>) => boolean;
 export declare const ValidFlowrFilters: Set<string>;
 export declare const ValidFlowrFiltersReverse: {
     [k: string]: string;
@@ -31,12 +36,18 @@ export declare const ValidFlowrFiltersReverse: {
 export declare const FlowrFilters: {
     readonly "drop-empty-arguments": (e: FlowrSearchElement<ParentInformation>, _args: never) => boolean;
     readonly "matches-enrichment": (e: FlowrSearchElement<ParentInformation>, args: MatchesEnrichmentArgs<Enrichment>) => boolean;
+    readonly "origin-kind": (e: FlowrSearchElement<ParentInformation>, args: OriginKindArgs, data: FlowrSearchInput<Pipeline>) => boolean;
 };
 export type FlowrFilterArgs<F extends FlowrFilter> = typeof FlowrFilters[F] extends FlowrFilterFunction<infer Args> ? Args : never;
-export interface MatchesEnrichmentArgs<E extends Enrichment> extends MergeableRecord {
+export interface MatchesEnrichmentArgs<E extends Enrichment> {
     enrichment: E;
     test: RegExp;
 }
+export interface OriginKindArgs {
+    origin: BuiltInMappingName | RegExp;
+    matchType?: 'some' | 'every';
+    keepNonFunctionCalls?: boolean;
+}
 export declare function testFunctionsIgnoringPackage(functions: string[]): RegExp;
 type ValidFilterTypes<F extends FlowrFilter = FlowrFilter> = FlowrFilterName | FlowrFilterWithArgs<F, FlowrFilterArgs<F>> | RType | VertexType;
 /**
@@ -91,8 +102,7 @@ export declare function isBinaryTree(tree: unknown): tree is {
 };
 interface FilterData {
     readonly element: FlowrSearchElement<ParentInformation>;
-    readonly normalize: NormalizedAst;
-    readonly dataflow: DataflowInformation;
+    readonly data: FlowrSearchInput<Pipeline>;
 }
 export declare function evalFilter<Filter extends FlowrFilter>(filter: FlowrFilterExpression<Filter>, data: FilterData): boolean;
 export {};

package/search/flowr-search-filters.js

@@ -21,6 +21,11 @@ var FlowrFilter;
      * To test for included function names in an enrichment like {@link Enrichment.CallTargets}, the helper function {@link testFunctionsIgnoringPackage} can be used.
      */
     FlowrFilter["MatchesEnrichment"] = "matches-enrichment";
+    /**
+     * Only returns search elements whose {@link FunctionOriginInformation} match a given pattern or value.
+     * This filter accepts {@link OriginKindArgs}, which includes the {@link DataflowGraphVertexFunctionCall.origin} to match for, whether to match for every or some origins, and whether to include non-function-calls in the filtered query.
+     */
+    FlowrFilter["OriginKind"] = "origin-kind";
 })(FlowrFilter || (exports.FlowrFilter = FlowrFilter = {}));
 exports.ValidFlowrFilters = new Set(Object.values(FlowrFilter));
 exports.ValidFlowrFiltersReverse = Object.fromEntries(Object.entries(FlowrFilter).map(([k, v]) => [v, k]));
@@ -31,6 +36,17 @@ exports.FlowrFilters = {
     [FlowrFilter.MatchesEnrichment]: ((e, args) => {
         const content = JSON.stringify((0, search_enrichers_1.enrichmentContent)(e, args.enrichment));
         return content !== undefined && args.test.test(content);
+    }),
+    [FlowrFilter.OriginKind]: ((e, args, data) => {
+        const dfgNode = data.dataflow.graph.getVertex(e.node.info.id);
+        if (!dfgNode || dfgNode.tag !== vertex_1.VertexType.FunctionCall) {
+            return args.keepNonFunctionCalls ?? false;
+        }
+        const match = typeof args.origin === 'string' ?
+            (origin) => args.origin === origin :
+            (origin) => args.origin.test(origin);
+        const origins = Array.isArray(dfgNode.origin) ? dfgNode.origin : [dfgNode.origin];
+        return args.matchType === 'every' ? origins.every(match) : origins.some(match);
     })
 };
 function testFunctionsIgnoringPackage(functions) {
@@ -140,13 +156,13 @@ const evalVisit = {
     xor: ({ left, right }, data) => evalTree(left, data) !== evalTree(right, data),
     not: ({ operand }, data) => !evalTree(operand, data),
     'r-type': ({ value }, { element }) => element.node.type === value,
-    'vertex-type': ({ value }, { dataflow: { graph }, element }) => graph.getVertex(element.node.info.id)?.tag === value,
-    'special': ({ value }, { element }) => {
+    'vertex-type': ({ value }, { data: { dataflow }, element }) => dataflow.graph.getVertex(element.node.info.id)?.tag === value,
+    'special': ({ value }, { data, element }) => {
         const name = typeof value === 'string' ? value : value.name;
         const args = typeof value === 'string' ? undefined : value.args;
         const getHandler = exports.FlowrFilters[name];
         if (getHandler) {
-            return getHandler(element, args);
+            return getHandler(element, args, data);
         }
         throw new Error(`Couldn't find special filter with name ${name}`);
     }

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

@@ -103,7 +103,7 @@ export declare const Enrichments: {
             normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
             dataflow: import("../../dataflow/info").DataflowInformation;
             config: import("../../config").FlowrConfigOptions;
-        }, args: Omit<LinkToLastCall<string | RegExp>, "type">[] | undefined, prev: LastCallContent | undefined) => LastCallContent;
+        }, args: Omit<LinkToLastCall<import("../../queries/catalog/call-context-query/call-context-query-format").CallNameTypes>, "type">[] | undefined, prev: LastCallContent | undefined) => LastCallContent;
         mapper: ({ linkedIds }: LastCallContent) => FlowrSearchElement<ParentInformation>[];
     };
     readonly "cfg-information": {

package/search/search-executor/search-enrichers.js

@@ -11,6 +11,7 @@ const extract_cfg_1 = require("../../control-flow/extract-cfg");
 const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const cfg_simplification_1 = require("../../control-flow/cfg-simplification");
+const call_context_query_executor_1 = require("../../queries/catalog/call-context-query/call-context-query-executor");
 /**
  * An enumeration that stores the names of the available enrichments that can be applied to a set of search elements.
  * See {@link FlowrSearchBuilder.with} for more information on how to apply enrichments.
@@ -74,11 +75,11 @@ exports.Enrichments = {
             const content = prev ?? { linkedIds: [] };
             const vertex = data.dataflow.graph.get(e.node.info.id);
             if (vertex !== undefined && vertex[0].tag === vertex_1.VertexType.FunctionCall) {
-                const cfg = (0, extract_cfg_1.extractSimpleCfg)(data.normalize);
+                const cfg = (0, extract_cfg_1.extractCfgQuick)(data.normalize);
                 for (const arg of args) {
                     const lastCalls = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(vertex[0].id, cfg.graph, data.dataflow.graph, {
                         ...arg,
-                        callName: new RegExp(arg.callName),
+                        callName: (0, call_context_query_executor_1.promoteCallName)(arg.callName),
                         type: 'link-to-last-call',
                     });
                     for (const lastCall of lastCalls) {

package/search/search-executor/search-generators.js

@@ -65,7 +65,7 @@ function generateFromQuery(data, args) {
         }
         const nodes = new Set();
         const queryDef = query_1.SupportedQueries[query];
-        for (const node of queryDef.flattenInvolvedNodes(content)) {
+        for (const node of queryDef.flattenInvolvedNodes(content, args.from)) {
             nodes.add({ node: data.normalize.idMap.get(node) });
         }
         nodesByQuery.set(query, nodes);

package/search/search-executor/search-transformer.js

@@ -93,7 +93,7 @@ function getSkip(data, elements, { count }) {
     return elements.mutate(e => sortFully(e).slice(count));
 }
 function getFilter(data, elements, { filter }) {
-    return elements.mutate(e => e.filter(e => (0, flowr_search_filters_1.evalFilter)(filter, { element: e, normalize: data.normalize, dataflow: data.dataflow })));
+    return elements.mutate(e => e.filter(e => (0, flowr_search_filters_1.evalFilter)(filter, { element: e, data })));
 }
 function getWith(data, elements, { info, args }) {
     return elements.enrich(data, info, args).mutate(s => s.map(e => (0, search_enrichers_1.enrichElement)(e, elements, data, info, args)));

package/util/objects.d.ts

@@ -10,12 +10,23 @@ type OrReadonly<T> = T | Readonly<T> | DeepReadonly<T>;
 /**
  * Given two objects deeply merges them, if an object is an array it will merge the array values!
  * Guarantees some type safety by requiring objects to merge to be from the same type (allows undefined)
+ *
+ * @see {@link deepMergeObjectInPlace} to merge into an existing object
  */
 export declare function deepMergeObject<T extends Mergeable>(base: Required<OrReadonly<T>>, addon?: T | DeepPartial<T> | Partial<T>): Required<T>;
 export declare function deepMergeObject<T extends Mergeable>(base: DeepRequired<OrReadonly<T>>, addon?: T | DeepPartial<T> | Partial<T>): DeepRequired<T>;
 export declare function deepMergeObject<T extends Mergeable>(base: OrReadonly<T>, addon?: DeepPartial<T> | Partial<T>): T;
 export declare function deepMergeObject(base: Mergeable, addon: Mergeable): Mergeable;
 export declare function deepMergeObject(base?: Mergeable, addon?: Mergeable): Mergeable | undefined;
+/**
+ * Given two objects deeply merges them, if an object is an array it will merge the array values!
+ * Modifies the `base` object in place and also returns it.
+ * Guarantees some type safety by requiring objects to merge to be from the same type (allows undefined)
+ *
+ * @see {@link deepMergeObject} to create a new merged object
+ */
+export declare function deepMergeObjectInPlace<T extends Mergeable>(base: T, addon?: DeepPartial<T> | Partial<T>): T;
+export declare function deepMergeObjectInPlace<T extends Mergeable>(base: T | undefined, addon?: DeepPartial<T> | Partial<T>): T | undefined;
 type Defined<T> = Exclude<T, undefined>;
 type DefinedRecord<T> = {
     [K in keyof T as T[K] extends undefined ? never : K]: Defined<T[K]>;

package/util/objects.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isObjectOrArray = isObjectOrArray;
 exports.deepMergeObject = deepMergeObject;
+exports.deepMergeObjectInPlace = deepMergeObjectInPlace;
 exports.compactRecord = compactRecord;
 const json_1 = require("./json");
 /**
@@ -56,6 +57,31 @@ function deepMergeObjectWithResult(addon, base, result) {
         }
     }
 }
+function deepMergeObjectInPlace(base, addon) {
+    if (!base) {
+        return addon;
+    }
+    else if (!addon) {
+        return base;
+    }
+    else if (typeof base !== 'object' || typeof addon !== 'object') {
+        // this case should be guarded by type guards, but in case we do not know
+        throw new Error('illegal types for deepMergeObjectInPlace!');
+    }
+    assertSameType(base, addon);
+    const baseIsArray = Array.isArray(base);
+    const addonIsArray = Array.isArray(addon);
+    if (!baseIsArray && !addonIsArray) {
+        deepMergeObjectWithResult(addon, base, base);
+    }
+    else if (baseIsArray && addonIsArray) {
+        (base).push(...addon);
+    }
+    else {
+        throw new Error('cannot merge object with array!');
+    }
+    return base;
+}
 function assertSameType(base, addon) {
     if (base !== undefined && addon !== undefined && typeof base !== typeof addon) {
         throw new Error(`cannot merge different types! ${typeof base} (${JSON.stringify(base, json_1.jsonReplacer)}) !== ${typeof addon} (${JSON.stringify(addon, json_1.jsonReplacer)})`);

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.4.7';
+const version = '2.4.8';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }