@eagleoutice/flowr 2.9.12 → 2.9.13

package/r-bridge/lang-4.x/ast/model/model.js

@@ -200,6 +200,7 @@ exports.RNode = {
      * Returns the direct parent of a node.
      * Usually, only root nodes do not have a parent, and you can assume that there is a
      * linear chain of parents leading to the root node.
+     * @see {@link iterateParents} - to get all parents of a node
      */
     directParent(node, idMap) {
         const parentId = node.info.parent;
@@ -208,6 +209,18 @@ exports.RNode = {
         }
         return idMap.get(parentId);
     },
+    /**
+     * Returns an iterable of all parents of a node, starting with the direct parent and ending with the root node.
+     */
+    *iterateParents(node, idMap) {
+        let currentNode = node;
+        while (currentNode) {
+            currentNode = exports.RNode.directParent(currentNode, idMap);
+            if (currentNode) {
+                yield currentNode;
+            }
+        }
+    },
     /**
      * In contrast to the nesting stored in the {@link RNode} structure,
      * this function calculates the depth of a node by counting the number of parents until the root node is reached.

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

@@ -1,7 +1,7 @@
 import { type IdGenerator, type NormalizedAst } from '../../model/processing/decorate';
 import type { NoInfo } from '../../model/model';
 import type { ParseStepOutput, ParseStepOutputSingleFile } from '../../../../parser';
-import { type FlowrConfigOptions } from '../../../../../config';
+import { FlowrConfig } from '../../../../../config';
 import type { Tree } from 'web-tree-sitter';
 import { RProject } from '../../model/nodes/r-project';
 export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
@@ -19,4 +19,4 @@ export declare function normalizeButNotDecorated({ parsed, filePath }: ParseStep
 /**
  * Tree-Sitter pendant to {@link normalize}.
  */
-export declare function normalizeTreeSitter(parsed: ParseStepOutput<Tree>, getId: IdGenerator<NoInfo> | undefined, config: FlowrConfigOptions): NormalizedAst;
+export declare function normalizeTreeSitter(parsed: ParseStepOutput<Tree>, getId?: IdGenerator<NoInfo>, config?: FlowrConfig): NormalizedAst;

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

@@ -32,8 +32,8 @@ function normalizeButNotDecorated({ parsed, filePath }) {
 /**
  * Tree-Sitter pendant to {@link normalize}.
  */
-function normalizeTreeSitter(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), config) {
-    const lax = (0, config_1.getEngineConfig)(config, 'tree-sitter')?.lax;
+function normalizeTreeSitter(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0), config = config_1.FlowrConfig.default()) {
+    const lax = config_1.FlowrConfig.getForEngine(config, 'tree-sitter')?.lax;
     const result = (0, decorate_1.decorateAst)((0, tree_sitter_normalize_1.normalizeTreeSitterTreeToAst)(parsed.files, lax), { getId });
     result.hasError = parsed.files.some(p => p.parsed.rootNode.hasError);
     return result;

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

@@ -224,14 +224,18 @@ function convertTreeNode(node) {
                 }
             }
             case tree_sitter_types_1.TreeSitterType.UnaryOperator: {
-                const [op, operand] = nonErrorChildren(node);
+                const [comments, children] = splitComments(nonErrorChildren(node));
+                const [op, operand] = children;
                 return {
                     type: type_1.RType.UnaryOp,
                     operand: convertTreeNode(operand),
                     location: makeSourceRange(op),
                     operator: op.text,
                     lexeme: op.text,
-                    ...defaultInfo
+                    info: {
+                        ...defaultInfo.info,
+                        adToks: comments.map(c => c[1]),
+                    }
                 };
             }
             case tree_sitter_types_1.TreeSitterType.NamespaceOperator: {

package/statistics/statistics.d.ts

@@ -4,7 +4,7 @@ import type { PipelineOutput } from '../core/steps/pipeline/pipeline';
 import { DEFAULT_DATAFLOW_PIPELINE } from '../core/steps/pipeline/default-pipelines';
 import type { RShell } from '../r-bridge/shell';
 import { type FeatureSelection, type FeatureStatistics } from './features/feature';
-import type { FlowrConfigOptions } from '../config';
+import type { FlowrConfig } from '../config';
 /**
  * By default, {@link extractUsageStatistics} requires a generator, but sometimes you already know all the files
  * that you want to process. This function simply reps your requests as a generator.
@@ -21,7 +21,7 @@ type DataflowResult = PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>;
  *                    If your request is statically known, you can use {@link staticRequests} to create this generator.
  * @param rootPath  - The root path to the project, this is used to relativize the file paths in the statistics.
  */
-export declare function extractUsageStatistics<T extends RParseRequestFromText | RParseRequestFromFile>(shell: RShell, config: FlowrConfigOptions, onRequest: (request: T) => void, features: FeatureSelection, requests: AsyncGenerator<T>, rootPath?: string): Promise<{
+export declare function extractUsageStatistics<T extends RParseRequestFromText | RParseRequestFromFile>(shell: RShell, config: FlowrConfig, onRequest: (request: T) => void, features: FeatureSelection, requests: AsyncGenerator<T>, rootPath?: string): Promise<{
     features: FeatureStatistics;
     meta: MetaStatistics;
     outputs: Map<T, DataflowResult>;

package/util/objects.d.ts

@@ -32,4 +32,16 @@ type DefinedRecord<T> = {
 export declare function compactRecord<T extends Record<string, unknown>>(record: T): DefinedRecord<T>;
 export declare function compactRecord(record: undefined): undefined;
 export declare function compactRecord<T extends Record<string, unknown>>(record: T | undefined): DefinedRecord<T> | undefined;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date | Function;
+/**
+ * Given an object type `T`, produces a union of string literal types representing all possible paths to primitive values within that object.
+ * Sadly, right now, the ts-essential paths property breaks when it comes to deeper nested objects
+ */
+export type AutocompletablePaths<T, Prefix extends string = ''> = T extends Primitive | readonly unknown[] ? never : {
+    [K in keyof T & string]: `${Prefix}${K}` | (T[K] extends Primitive | readonly unknown[] ? never : AutocompletablePaths<T[K], `${Prefix}${K}.`>);
+}[keyof T & string];
+/**
+ * This is a version of a deep clone that preserves unclonable values (like functions, symbols, ...) by keeping the same reference to them.
+ */
+export declare function deepClonePreserveUnclonable<T>(obj: T): T;
 export {};

package/util/objects.js

@@ -4,6 +4,7 @@ exports.isObjectOrArray = isObjectOrArray;
 exports.deepMergeObject = deepMergeObject;
 exports.deepMergeObjectInPlace = deepMergeObjectInPlace;
 exports.compactRecord = compactRecord;
+exports.deepClonePreserveUnclonable = deepClonePreserveUnclonable;
 const json_1 = require("./json");
 /**
  * checks if `item` is an object (it may be an array, ...)
@@ -100,4 +101,31 @@ function compactRecord(record) {
     }
     return result;
 }
+/**
+ * This is a version of a deep clone that preserves unclonable values (like functions, symbols, ...) by keeping the same reference to them.
+ */
+function deepClonePreserveUnclonable(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    else if (Array.isArray(obj)) {
+        return obj.map(deepClonePreserveUnclonable);
+    }
+    else if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    else if (obj instanceof Map) {
+        return new Map(obj.entries().map(([k, v]) => [deepClonePreserveUnclonable(k), deepClonePreserveUnclonable(v)]));
+    }
+    else if (obj instanceof Set) {
+        return new Set(obj.values().map(deepClonePreserveUnclonable));
+    }
+    else {
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            result[key] = deepClonePreserveUnclonable(obj[key]);
+        }
+        return result;
+    }
+}
 //# sourceMappingURL=objects.js.map

package/util/summarizer.js

@@ -34,7 +34,7 @@ function summarizeMeasurement(data, totalNumberOfDataPoints) {
     // just to avoid in-place modification
     const sorted = [...data].sort((a, b) => a - b);
     const min = sorted[0];
-    const max = sorted[sorted.length - 1];
+    const max = sorted.at(-1);
     const median = sorted[Math.floor(sorted.length / 2)];
     const total = (0, arrays_1.arraySum)(sorted);
     const length = totalNumberOfDataPoints ?? sorted.length;

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.9.12';
+const version = '2.9.13';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */