@eagleoutice/flowr 2.1.8 → 2.1.10

package/util/list-access.d.ts

@@ -0,0 +1,48 @@
+import type { REnvironmentInformation } from '../dataflow/environments/environment';
+import type { ContainerIndices, ContainerIndicesCollection } from '../dataflow/graph/vertex';
+import type { RAccess } from '../r-bridge/lang-4.x/ast/model/nodes/r-access';
+import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
+ *
+ * @param accessedArg - The argument to resolve
+ * @param accessArg - The argument which is used to filter the indices
+ * @param environment - The environment in which {@link accessedArg} is resolved
+ * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
+ */
+export declare function resolveSingleIndex(accessedArg: {
+    lexeme: string;
+}, accessArg: {
+    lexeme: string;
+}, environment: REnvironmentInformation): ContainerIndicesCollection;
+/**
+ * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
+ *
+ * @param indicesCollection - The {@link ContainerIndicesCollection} to filter
+ * @param accessArg - The argument which is used to filter {@link indicesCollection}
+ * @returns The filtered copy of {@link indicesCollection}
+ */
+export declare function filterIndices(indicesCollection: ContainerIndicesCollection, accessArg: {
+    lexeme: string;
+}): ContainerIndicesCollection;
+/**
+ * Constructs the definition of a nested access.
+ *
+ * Example:
+ * ```r
+ * person$credentials$username
+ * ```
+ * would result in a list with the index `credentials`, which has the subIndex `username`.
+ *
+ * @param accessedArg - The top level argument that is accessed
+ * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @returns The constructed nested access
+ */
+export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<OtherInfo & ParentInformation>, leafIndices: ContainerIndices): ContainerIndices[];
+/**
+ * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
+ *
+ * @param indicesCollection - Indices where to add the sub indices.
+ * @param leafSubIndices - Indices that are added to the leaf indices.
+ */
+export declare function addSubIndicesToLeafIndices(indicesCollection: ContainerIndices[], leafSubIndices: ContainerIndices[]): ContainerIndices[];

package/util/list-access.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSingleIndex = resolveSingleIndex;
+exports.filterIndices = filterIndices;
+exports.constructNestedAccess = constructNestedAccess;
+exports.addSubIndicesToLeafIndices = addSubIndicesToLeafIndices;
+const resolve_by_name_1 = require("../dataflow/environments/resolve-by-name");
+const vertex_1 = require("../dataflow/graph/vertex");
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+/**
+ * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
+ *
+ * @param accessedArg - The argument to resolve
+ * @param accessArg - The argument which is used to filter the indices
+ * @param environment - The environment in which {@link accessedArg} is resolved
+ * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
+ */
+function resolveSingleIndex(accessedArg, accessArg, environment) {
+    const definitions = (0, resolve_by_name_1.resolveByName)(accessedArg.lexeme, environment);
+    const indicesCollection = definitions?.flatMap(def => def?.indicesCollection ?? []);
+    const accessedIndicesCollection = filterIndices(indicesCollection, accessArg);
+    return accessedIndicesCollection;
+}
+/**
+ * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
+ *
+ * @param indicesCollection - The {@link ContainerIndicesCollection} to filter
+ * @param accessArg - The argument which is used to filter {@link indicesCollection}
+ * @returns The filtered copy of {@link indicesCollection}
+ */
+function filterIndices(indicesCollection, accessArg) {
+    let accessedIndicesCollection = undefined;
+    for (const indices of indicesCollection ?? []) {
+        const filteredIndices = indices.indices.filter(index => accessArg.lexeme === index.lexeme);
+        if (filteredIndices.length == 0) {
+            continue;
+        }
+        accessedIndicesCollection ??= [];
+        accessedIndicesCollection.push({
+            indices: filteredIndices,
+            isContainer: indices.isContainer
+        });
+    }
+    return accessedIndicesCollection;
+}
+/**
+ * Constructs the definition of a nested access.
+ *
+ * Example:
+ * ```r
+ * person$credentials$username
+ * ```
+ * would result in a list with the index `credentials`, which has the subIndex `username`.
+ *
+ * @param accessedArg - The top level argument that is accessed
+ * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @returns The constructed nested access
+ */
+function constructNestedAccess(accessedArg, leafIndices) {
+    const accessed = accessedArg.accessed;
+    const accesses = accessedArg.access.filter(arg => arg !== r_function_call_1.EmptyArgument).map(arg => arg);
+    const indices = [];
+    for (const access of accesses) {
+        const newIndices = {
+            indices: [
+                {
+                    lexeme: access.lexeme,
+                    nodeId: access.info.id,
+                    subIndices: [leafIndices],
+                }
+            ],
+            isContainer: false,
+        };
+        if (accessed.type === type_1.RType.Access) {
+            const nestedIndices = constructNestedAccess(accessed, newIndices);
+            indices.push(...nestedIndices);
+        }
+        else {
+            indices.push(newIndices);
+        }
+    }
+    return indices;
+}
+/**
+ * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
+ *
+ * @param indicesCollection - Indices where to add the sub indices.
+ * @param leafSubIndices - Indices that are added to the leaf indices.
+ */
+function addSubIndicesToLeafIndices(indicesCollection, leafSubIndices) {
+    const result = [];
+    for (const indices of indicesCollection) {
+        const newIndices = [];
+        for (const index of indices.indices) {
+            let newSubIndices = [];
+            if ((0, vertex_1.isParentContainerIndex)(index)) {
+                newSubIndices = addSubIndicesToLeafIndices(index.subIndices, leafSubIndices);
+            }
+            else {
+                newSubIndices = leafSubIndices;
+            }
+            newIndices.push({
+                ...index,
+                subIndices: newSubIndices,
+            });
+        }
+        result.push({
+            ...indices,
+            indices: newIndices,
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=list-access.js.map

package/util/mermaid/cfg.js

@@ -16,7 +16,7 @@ function cfgToMermaid(cfg, normalizedAst, prefix = '') {
             output += `    n${id}[${name}]\n`;
         }
         else {
-            output += `    n${id}(( ))\n`;
+            output += String(id).endsWith('-exit') ? `    n${id}((${id}))\n` : `    n${id}[[${id}]]\n`;
         }
     }
     for (const [from, targets] of cfg.graph.edges()) {

package/util/summarizer.js

@@ -27,11 +27,11 @@ function summarizeMeasurement(data, totalNumberOfDataPoints) {
     const min = sorted[0];
     const max = sorted[sorted.length - 1];
     const median = sorted[Math.floor(sorted.length / 2)];
-    const total = (0, arrays_1.sum)(sorted);
+    const total = (0, arrays_1.arraySum)(sorted);
     const length = totalNumberOfDataPoints ?? sorted.length;
     const mean = total / length;
     // sqrt(sum(x-mean)^2 / n)
-    const std = Math.sqrt(sorted.map(x => (x - mean) ** 2).reduce((a, b) => a + b, 0) / length);
+    const std = Math.sqrt((0, arrays_1.arraySum)(sorted.map(x => (x - mean) ** 2)) / length);
     return { min, max, median, mean, std, total };
 }
 //# sourceMappingURL=summarizer.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.1.8';
+const version = '2.1.10';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }