@eagleoutice/flowr 2.2.2 → 2.2.3

package/r-bridge/lang-4.x/ast/parser/json/format.d.ts

@@ -36,6 +36,12 @@ export interface NamedJsonEntry {
     name: RawRType;
     content: JsonEntry;
 }
+/**
+ * Takes the raw {@link RShell} output and extracts the csv information contained
+ */
 export declare function prepareParsedData(data: string): CsvEntry[];
+/**
+ * Takes the CSV-Entries and maps them to the old json format for compatibility.
+ */
 export declare function convertPreparedParsedData(roots: readonly CsvEntry[]): JsonEntry;
 export {};

package/r-bridge/lang-4.x/ast/parser/json/format.js

@@ -7,6 +7,9 @@ const retriever_1 = require("../../../../retriever");
 const assert_1 = require("../../../../../util/assert");
 const type_1 = require("../../model/type");
 exports.RootId = 0;
+/**
+ * Takes the raw {@link RShell} output and extracts the csv information contained
+ */
 function prepareParsedData(data) {
     let json;
     try {
@@ -36,6 +39,9 @@ function prepareParsedData(data) {
     }
     return roots;
 }
+/**
+ * Takes the CSV-Entries and maps them to the old json format for compatibility.
+ */
 function convertPreparedParsedData(roots) {
     const partialEntry = {
         token: type_1.RawRType.ExpressionList,

package/r-bridge/lang-4.x/ast/parser/json/parser.d.ts

@@ -1,10 +1,21 @@
 import type { IdGenerator, NormalizedAst } from '../../model/processing/decorate';
-import type { NoInfo } from '../../model/model';
+import type { NoInfo, RNode } from '../../model/model';
 import type { ParseStepOutputTS } from '../../../../../core/steps/all/core/01-parse-tree-sitter';
 import type { ParseStepOutput } from '../../../../parser';
 export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.
+ *
+ * @see {@link normalizeButNotDecorated} for a version that does not decorate the AST
+ * @see {@link normalizeTreeSitter} for a version that normalizes the AST from the TreeSitter parser
+ */
+export declare function normalize(parsed: ParseStepOutput<string>, getId?: IdGenerator<NoInfo>, file?: string): NormalizedAst;
+/**
+ * Take the output as produced by the parse step and normalize the AST from the R parser.
+ * For additional decoration with ${@link decorateAst} use {@link normalize}.
+ */
+export declare function normalizeButNotDecorated({ parsed }: ParseStepOutput<string>): RNode;
+/**
+ * Tree-Sitter pendant to {@link normalize}.
  */
-export declare function normalize({ parsed }: ParseStepOutput<string>, getId?: IdGenerator<NoInfo>, file?: string): NormalizedAst;
 export declare function normalizeTreeSitter({ parsed }: ParseStepOutputTS, getId?: IdGenerator<NoInfo>, file?: string): NormalizedAst;

package/r-bridge/lang-4.x/ast/parser/json/parser.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseLog = void 0;
 exports.normalize = normalize;
+exports.normalizeButNotDecorated = normalizeButNotDecorated;
 exports.normalizeTreeSitter = normalizeTreeSitter;
 const format_1 = require("./format");
 const log_1 = require("../../../../../util/log");
@@ -11,13 +12,28 @@ const tree_sitter_normalize_1 = require("../../../tree-sitter/tree-sitter-normal
 exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.
+ *
+ * @see {@link normalizeButNotDecorated} for a version that does not decorate the AST
+ * @see {@link normalizeTreeSitter} for a version that normalizes the AST from the TreeSitter parser
  */
-function normalize({ parsed }, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), file) {
+function normalize(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), file) {
+    return (0, decorate_1.decorateAst)(normalizeButNotDecorated(parsed), { getId, file });
+}
+/**
+ * Take the output as produced by the parse step and normalize the AST from the R parser.
+ * For additional decoration with ${@link decorateAst} use {@link normalize}.
+ */
+function normalizeButNotDecorated({ parsed }) {
     const data = { currentRange: undefined, currentLexeme: undefined };
     const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(parsed));
-    return (0, decorate_1.decorateAst)((0, normalize_root_1.normalizeRootObjToAst)(data, object), { getId, file });
+    return (0, normalize_root_1.normalizeRootObjToAst)(data, object);
 }
+/**
+ * Tree-Sitter pendant to {@link normalize}.
+ */
 function normalizeTreeSitter({ parsed }, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), file) {
-    return (0, decorate_1.decorateAst)((0, tree_sitter_normalize_1.normalizeTreeSitterTreeToAst)(parsed), { getId, file });
+    const result = (0, decorate_1.decorateAst)((0, tree_sitter_normalize_1.normalizeTreeSitterTreeToAst)(parsed), { getId, file });
+    result.hasError = parsed.rootNode.hasError;
+    return result;
 }
 //# sourceMappingURL=parser.js.map

package/r-bridge/lang-4.x/ast/parser/main/internal/structure/normalize-root.d.ts

@@ -1,4 +1,7 @@
 import type { NormalizerData } from '../../normalizer-data';
 import type { RExpressionList } from '../../../../model/nodes/r-expression-list';
 import type { JsonEntry } from '../../../json/format';
+/**
+ * Takes the parse dta as object and produces an undecorated, normalized AST.
+ */
 export declare function normalizeRootObjToAst(data: NormalizerData, obj: JsonEntry): RExpressionList;

package/r-bridge/lang-4.x/ast/parser/main/internal/structure/normalize-root.js

@@ -6,6 +6,9 @@ const normalize_expressions_1 = require("./normalize-expressions");
 const log_1 = require("../../../../../../../util/log");
 const arrays_1 = require("../../../../../../../util/arrays");
 const type_1 = require("../../../../model/type");
+/**
+ * Takes the parse dta as object and produces an undecorated, normalized AST.
+ */
 function normalizeRootObjToAst(data, obj) {
     const exprContent = obj.token;
     (0, normalize_meta_1.assureTokenType)(exprContent, type_1.RawRType.ExpressionList);

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.js

@@ -18,7 +18,12 @@ function normalizeTreeSitterTreeToAst(tree) {
     return root;
 }
 function nonErrorChildren(node) {
-    return node.children.filter(n => n.type !== tree_sitter_types_1.TreeSitterType.Error);
+    if (node.hasError) {
+        return [];
+    }
+    else {
+        return node.children;
+    }
 }
 function convertTreeNode(node) {
     // generally, the grammar source file dictates what children a node has in what order:

package/r-bridge/parser.d.ts

@@ -27,6 +27,16 @@ export interface ParseRequiredInput<T> {
 export interface ParseStepOutput<T> {
     /** The parsed AST of the R code as given by the R parse side */
     readonly parsed: T;
+    /** Additional meta information about the parse */
+    readonly '.parse-meta'?: {
+        /** The number of tokens in the AST */
+        readonly tokenCount: number;
+    };
 }
+/**
+ * Takes an input program and parses it using the given parser.
+ * @param _results - just a proxy for the pipeline, signifies that this function does not need prior knowledge of the pipeline
+ * @param input    - the input to the parse step
+ */
 export declare function parseRequests<T extends KnownParserType>(_results: unknown, input: Partial<ParseRequiredInput<T>>): Promise<ParseStepOutput<T>>;
 export {};

package/r-bridge/parser.js

@@ -1,14 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRequests = parseRequests;
+function countChildren(node) {
+    let ret = 1;
+    for (const child of node.children) {
+        ret += countChildren(child);
+    }
+    return ret;
+}
+/**
+ * Takes an input program and parses it using the given parser.
+ * @param _results - just a proxy for the pipeline, signifies that this function does not need prior knowledge of the pipeline
+ * @param input    - the input to the parse step
+ */
 async function parseRequests(_results, input) {
     /* in the future, we want to expose all cases */
     const request = (Array.isArray(input.request) ? input.request[0] : input.request);
     if (input.parser?.async) {
-        return { parsed: await input.parser.parse(request) };
+        const parsed = await input.parser.parse(request);
+        return {
+            parsed,
+            '.parse-meta': typeof parsed === 'object' && 'rootNode' in parsed ? {
+                tokenCount: countChildren(parsed.rootNode),
+            } : undefined
+        };
     }
     else {
-        return { parsed: input.parser.parse(request) };
+        const parsed = input.parser.parse(request);
+        return {
+            parsed,
+            '.parse-meta': typeof parsed === 'object' && 'rootNode' in parsed ? {
+                tokenCount: countChildren(parsed.rootNode),
+            } : undefined
+        };
     }
 }
 //# sourceMappingURL=parser.js.map

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

@@ -111,7 +111,6 @@ export declare const Q: {
     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.
@@ -172,7 +171,7 @@ export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transf
     /**
      * 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>]>>;
+    merge<Generator2 extends GeneratorNames, Transformers2 extends TransformerNames[], OtherElementType extends FlowrSearchElements<Info, FlowrSearchElement<Info>[]>>(other: FlowrSearchBuilder<Generator2, Transformers2, Info, OtherElementType>): FlowrSearchBuilder<Generator, Transformers, Info>;
     /**
      * Construct the final search (this may happen automatically with most search handlers).
      *

package/search/flowr-search-builder.js

@@ -161,9 +161,7 @@ class FlowrSearchBuilder {
     /**
      * 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
-    ) {
+    merge(other /* | FlowrSearch<Info, Generator2, Transformers2, OtherElementType> */) {
         this.search.push({ type: 'transformer', name: 'merge', args: { generator: other.generator, search: other.search } });
         return this;
     }

package/util/mermaid/dfg.d.ts

@@ -18,6 +18,8 @@ interface MermaidGraph {
     /** in the form of from-\>to because I am lazy, see {@link encodeEdge} */
     presentEdges: Set<string>;
     rootGraph: DataflowGraph;
+    /** if given, the dataflow graph will only focus on the "important" parts */
+    simplified?: boolean;
 }
 /**
  * Prints a {@link SourceRange|range} as a human readable string.
@@ -33,6 +35,7 @@ interface MermaidGraphConfiguration {
     markStyle?: MermaidMarkStyle;
     rootGraph?: DataflowGraph;
     presentEdges?: Set<string>;
+    simplified?: boolean;
 }
 export declare function graphToMermaid(config: MermaidGraphConfiguration): {
     string: string;

package/util/mermaid/dfg.js

@@ -37,14 +37,24 @@ function subflowToMermaid(nodeId, exitPoints, subflow, mermaid, idPrefix = '') {
         return;
     }
     const subflowId = `${idPrefix}flow-${nodeId}`;
-    mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
+    if (mermaid.simplified) {
+        // get parent
+        const idMap = mermaid.rootGraph.idMap;
+        const node = idMap?.get(nodeId);
+        const nodeLexeme = node?.info.fullLexeme ?? node?.lexeme ?? '??';
+        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme ?? 'function')}"]`);
+    }
+    else {
+        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
+    }
     const subgraph = graphToMermaidGraph(subflow.graph, {
         graph: mermaid.rootGraph,
         rootGraph: mermaid.rootGraph,
         idPrefix,
         includeEnvironments: mermaid.includeEnvironments,
         mark: mermaid.mark,
-        prefix: null
+        prefix: null,
+        simplified: mermaid.simplified
     });
     mermaid.nodeLines.push(...subgraph.nodeLines);
     mermaid.edgeLines.push(...subgraph.edgeLines);
@@ -143,10 +153,16 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     }
     const node = mermaid.rootGraph.idMap?.get(info.id);
     const lexeme = node?.lexeme ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0]?.lexeme : '') ?? '??';
-    const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
-    const deps = info.controlDependencies ? ', :may:' + info.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
-    const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
-    mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+    if (mermaid.simplified) {
+        const escapedName = '**' + (0, mermaid_1.escapeMarkdown)(node ? `${lexeme}` : '??') + '**' + (node ? `\n*${node.type}*` : '');
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}\`"${close}`);
+    }
+    else {
+        const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
+        const deps = info.controlDependencies ? ', :may:' + info.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
+        const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+    }
     if (mark?.has(id)) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} ${mermaid.markStyle.vertex} `);
     }
@@ -176,8 +192,8 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     }
 }
 // make the passing of root ids more performant again
-function graphToMermaidGraph(rootIds, { graph, prefix = 'flowchart TD', idPrefix = '', includeEnvironments = true, mark, rootGraph, presentEdges = new Set(), markStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' } }) {
-    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle };
+function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart TD', idPrefix = '', includeEnvironments = !simplified, mark, rootGraph, presentEdges = new Set(), markStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' } }) {
+    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle, simplified };
     for (const [id, info] of graph.vertices(true)) {
         if (rootIds.has(id)) {
             vertexToMermaid(info, mermaid, id, idPrefix, mark);

package/util/strings.d.ts

@@ -10,3 +10,12 @@ export declare function withoutWhitespace(output: string): string;
  * Find the longest common prefix in an array of strings
  */
 export declare function longestCommonPrefix(strings: string[]): string;
+/**
+ * Join a list of strings, but with special handling for the last element/scenarios in which the array contains exactly two elements.
+ * The goal is to create (partial) sentences like `a, b, and c` or `a and b`.
+ */
+export declare function joinWithLast(strs: readonly string[], { join, last, joinTwo }?: {
+    join?: string;
+    last?: string;
+    joinTwo?: string;
+}): string;

package/util/strings.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startAndEndsWith = startAndEndsWith;
 exports.withoutWhitespace = withoutWhitespace;
 exports.longestCommonPrefix = longestCommonPrefix;
+exports.joinWithLast = joinWithLast;
 /**
  * Check if the given string starts and ends with the given letter
  */
@@ -37,4 +38,17 @@ function longestCommonPrefix(strings) {
     }
     return prefix;
 }
+/**
+ * Join a list of strings, but with special handling for the last element/scenarios in which the array contains exactly two elements.
+ * The goal is to create (partial) sentences like `a, b, and c` or `a and b`.
+ */
+function joinWithLast(strs, { join = ', ', last = ', and ', joinTwo = ' and ' } = {}) {
+    if (strs.length <= 1) {
+        return strs.join('');
+    }
+    else if (strs.length === 2) {
+        return strs.join(joinTwo);
+    }
+    return strs.slice(0, -1).join(join) + last + strs[strs.length - 1];
+}
 //# sourceMappingURL=strings.js.map

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.2.2';
+const version = '2.2.3';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }