@eagleoutice/flowr 2.10.1 → 2.10.2

package/r-bridge/roxygen2/roxygen-ast.d.ts

@@ -196,7 +196,9 @@ export type RoxygenOtherTag = RoxygenTagAuthor | RoxygenUnknownTag | RoxygenDocT
 /**
  * All known Roxygen tag types.
  */
-export type RoxygenTag = RoxygenCrossrefTag | RoxygenNamespaceTag | RoxygenFormattingTag | RoxygenDatasetDocumentationTag | RoxygenFunctionDocumentationTag | RoxygenReusingDocumentationTag | RoxygenOtherTag;
+export type RoxygenTag = (RoxygenCrossrefTag | RoxygenNamespaceTag | RoxygenFormattingTag | RoxygenDatasetDocumentationTag | RoxygenFunctionDocumentationTag | RoxygenReusingDocumentationTag | RoxygenOtherTag) & {
+    inherited?: boolean;
+};
 /**
  * A roxygen comment block, consisting of multiple {@link RoxygenTag|roxygen tags}.
  */

package/search/flowr-search-builder.js

@@ -5,6 +5,7 @@ exports.getFlowrSearch = getFlowrSearch;
 const search_optimizer_1 = require("./search-optimizer/search-optimizer");
 const assert_1 = require("../util/assert");
 const search_mappers_1 = require("./search-executor/search-mappers");
+const AllGeneratorObj = { type: 'generator', name: 'all', args: undefined };
 /**
  * This object holds all the methods to generate search queries.
  * For compatibility, please use the {@link Q} identifier object to access these methods.
@@ -37,7 +38,7 @@ exports.FlowrSearchGenerator = {
      * Returns all elements (nodes/dataflow vertices) from the given data.
      */
     all() {
-        return new FlowrSearchBuilder({ type: 'generator', name: 'all', args: undefined });
+        return new FlowrSearchBuilder(AllGeneratorObj);
     },
     /**
      * Returns all elements that match the given {@link FlowrSearchGetFilters|filters}.
@@ -46,7 +47,7 @@ exports.FlowrSearchGenerator = {
      */
     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.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 } });
     },

package/util/mermaid/ast.js

@@ -57,7 +57,8 @@ function normalizedAstToMermaid(ast, { prefix = 'flowchart TD\n', markStyle = in
             // add a subgraph for each file
             if (ast.files.length !== 1 || (f.filePath && f.filePath !== flowr_file_1.FlowrFile.INLINE_PATH)) {
                 const direction = identifyMermaidDirection(prefix);
-                output += `    subgraph "File: ${mermaid_1.Mermaid.escape(f.filePath ?? flowr_file_1.FlowrFile.INLINE_PATH)}" direction ${direction}\n`;
+                output += `    subgraph "File: ${mermaid_1.Mermaid.escape(f.filePath ?? flowr_file_1.FlowrFile.INLINE_PATH)}"\n`;
+                output += `    direction ${direction}\n`;
                 showAst(f.root);
                 output += '    end\n';
             }

package/util/record.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Helper for transforming records.
+ */
+export declare const Record: {
+    /**
+     * Transforms a record by applying a callback function to each key-value pair in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each key-value pair of the record.
+     */
+    map<K1 extends string, K2 extends string, V1, V2>(this: void, object: Record<K1, V1>, callbackfn: (entry: [K1, V1], index: number, entries: [K1, V1][]) => [K2, V2]): Record<K2, V2>;
+    /**
+     * Transforms a record by applying a callback function to each key in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each key of the record.
+     */
+    mapKeys<K1 extends string, K2 extends string, V>(this: void, object: Record<K1, V>, callbackfn: (key: K1, index: number, entries: [K1, V][]) => K2): Record<K2, V>;
+    /**
+     * Transforms a record by applying a callback function to each property value in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each property value of the record.
+     */
+    mapProperties<K extends string, V1, V2>(this: void, object: Record<K, V1>, callbackfn: (value: V1, index: number, entries: [K, V1][]) => V2): Record<K, V2>;
+};

package/util/record.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Record = void 0;
+/**
+ * Helper for transforming records.
+ */
+exports.Record = {
+    /**
+     * Transforms a record by applying a callback function to each key-value pair in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each key-value pair of the record.
+     */
+    map(object, callbackfn) {
+        return Object.fromEntries(Object.entries(object).map(callbackfn));
+    },
+    /**
+     * Transforms a record by applying a callback function to each key in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each key of the record.
+     */
+    mapKeys(object, callbackfn) {
+        return exports.Record.map(object, ([key, value], index, entries) => [callbackfn(key, index, entries), value]);
+    },
+    /**
+     * Transforms a record by applying a callback function to each property value in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each property value of the record.
+     */
+    mapProperties(object, callbackfn) {
+        return exports.Record.map(object, ([keys, value], index, entries) => [keys, callbackfn(value, index, entries)]);
+    }
+};
+//# sourceMappingURL=record.js.map

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.10.1';
+const version = '2.10.2';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */

package/abstract-interpretation/domains/mapped-abstract-domain.d.ts

@@ -1,41 +0,0 @@
-import { AbstractDomain, type AnyAbstractDomain, type ConcreteDomain } from './abstract-domain';
-import { Top } from './lattice';
-/** The type of the concrete mapping of the concrete domain of a mapped abstract domain mapping keys to a concrete value in the concrete domain */
-export type ConcreteMap<Key, Domain extends AnyAbstractDomain> = ReadonlyMap<Key, ConcreteDomain<Domain>>;
-/**
- * A mapped abstract domain as mapping of keys to abstract values of an abstract domain.
- * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing key to Top.
- * @template Key       - Type of the keys of the mapping to abstract values
- * @template Domain    - Type of the abstract domain to map the keys to
- */
-export declare class MappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends AbstractDomain<ConcreteMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>> {
-    constructor(value: ReadonlyMap<Key, Domain>);
-    create(value: ReadonlyMap<Key, Domain>): this;
-    get(key: Key): Domain | undefined;
-    has(key: Key): boolean;
-    protected set(key: Key, value: Domain): void;
-    protected remove(key: Key): void;
-    bottom(): this;
-    top(): this;
-    equals(other: this): boolean;
-    leq(other: this): boolean;
-    join(other: this): this;
-    meet(other: this): this;
-    widen(other: this): this;
-    narrow(other: this): this;
-    concretize(limit: number): ReadonlySet<ConcreteMap<Key, Domain>> | typeof Top;
-    abstract(concrete: ReadonlySet<ConcreteMap<Key, Domain>> | typeof Top): this;
-    toJson(): unknown;
-    toString(): string;
-    isTop(): this is this;
-    isBottom(): this is this;
-    isValue(): this is this;
-}
-/**
- * A mutable version of the {@link MappedAbstractDomain} with {@link MutableMappedAbstractDomain#set|`set`} and {@link MutableMappedAbstractDomain#remove|`remove`}.
- */
-export declare class MutableMappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends MappedAbstractDomain<Key, Domain> {
-    create(value: ReadonlyMap<Key, Domain>): this;
-    set(key: Key, value: Domain): void;
-    remove(key: Key): void;
-}

package/abstract-interpretation/domains/mapped-abstract-domain.js

@@ -1,213 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutableMappedAbstractDomain = exports.MappedAbstractDomain = void 0;
-const abstract_domain_1 = require("./abstract-domain");
-const lattice_1 = require("./lattice");
-/**
- * A mapped abstract domain as mapping of keys to abstract values of an abstract domain.
- * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing key to Top.
- * @template Key       - Type of the keys of the mapping to abstract values
- * @template Domain    - Type of the abstract domain to map the keys to
- */
-class MappedAbstractDomain extends abstract_domain_1.AbstractDomain {
-    constructor(value) {
-        super(new Map(value));
-    }
-    create(value) {
-        return new MappedAbstractDomain(value);
-    }
-    get(key) {
-        return this._value.get(key);
-    }
-    has(key) {
-        return this._value.has(key);
-    }
-    set(key, value) {
-        this._value.set(key, value);
-    }
-    remove(key) {
-        this._value.delete(key);
-    }
-    bottom() {
-        return this.create(new Map());
-    }
-    top() {
-        const result = this.create(this.value);
-        for (const [key, value] of result.value) {
-            result.set(key, value.top());
-        }
-        return result;
-    }
-    equals(other) {
-        if (this.value === other.value) {
-            return true;
-        }
-        else if (this.value.size !== other.value.size) {
-            return false;
-        }
-        for (const [key, value] of this.value) {
-            const otherValue = other.get(key);
-            if (otherValue === undefined || !value.equals(otherValue)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    leq(other) {
-        if (this.value === other.value) {
-            return true;
-        }
-        else if (this.value.size > other.value.size) {
-            return false;
-        }
-        for (const [key, value] of this.value) {
-            const otherValue = other.get(key);
-            if (otherValue === undefined || !value.leq(otherValue)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    join(other) {
-        const result = this.create(this.value);
-        for (const [key, value] of other.value) {
-            const currValue = result.get(key);
-            if (currValue === undefined) {
-                result.set(key, value);
-            }
-            else {
-                result.set(key, currValue.join(value));
-            }
-        }
-        return result;
-    }
-    meet(other) {
-        const result = this.create(this.value);
-        for (const [key] of result.value) {
-            if (!other.has(key)) {
-                result.remove(key);
-            }
-        }
-        for (const [key, value] of other.value) {
-            const currValue = result.get(key);
-            if (currValue !== undefined) {
-                result.set(key, currValue.meet(value));
-            }
-        }
-        return result;
-    }
-    widen(other) {
-        const result = this.create(this.value);
-        for (const [key, value] of other.value) {
-            const currValue = result.get(key);
-            if (currValue === undefined) {
-                result.set(key, value);
-            }
-            else {
-                result.set(key, currValue.widen(value));
-            }
-        }
-        return result;
-    }
-    narrow(other) {
-        const result = this.create(this.value);
-        for (const [key] of this.value) {
-            if (!other.has(key)) {
-                result.remove(key);
-            }
-        }
-        for (const [key, value] of other.value) {
-            const currValue = result.get(key);
-            if (currValue !== undefined) {
-                result.set(key, currValue.narrow(value));
-            }
-        }
-        return result;
-    }
-    concretize(limit) {
-        if (this.value.size === 0) {
-            return new Set();
-        }
-        let mappings = new Set([new Map()]);
-        for (const [key, value] of this.value) {
-            const concreteValues = value.concretize(limit);
-            if (concreteValues === lattice_1.Top) {
-                return lattice_1.Top;
-            }
-            const newMappings = new Set();
-            for (const state of mappings) {
-                for (const concrete of concreteValues) {
-                    if (newMappings.size > limit) {
-                        return lattice_1.Top;
-                    }
-                    const map = new Map(state);
-                    map.set(key, concrete);
-                    newMappings.add(map);
-                }
-            }
-            mappings = newMappings;
-        }
-        return mappings;
-    }
-    abstract(concrete) {
-        if (concrete === lattice_1.Top) {
-            return this.top();
-        }
-        else if (concrete.size === 0) {
-            return this.bottom();
-        }
-        const domain = this.value.values().toArray()[0];
-        if (domain === undefined) {
-            return this.top();
-        }
-        const mapping = new Map();
-        for (const concreteMapping of concrete) {
-            for (const [key, value] of concreteMapping) {
-                const set = mapping.get(key);
-                if (set === undefined) {
-                    mapping.set(key, new Set([value]));
-                }
-                else {
-                    set.add(value);
-                }
-            }
-        }
-        const result = new Map();
-        for (const [key, values] of mapping) {
-            result.set(key, domain.abstract(values));
-        }
-        return this.create(result);
-    }
-    toJson() {
-        return Object.fromEntries(this.value.entries().map(([key, value]) => [key, value.toJson()]));
-    }
-    toString() {
-        return '(' + this.value.entries().toArray().map(([key, value]) => `${(0, abstract_domain_1.domainElementToString)(key)} -> ${value.toString()}`).join(', ') + ')';
-    }
-    isTop() {
-        return this.value.values().some(entry => entry.isTop());
-    }
-    isBottom() {
-        return this.value.size === 0;
-    }
-    isValue() {
-        return true;
-    }
-}
-exports.MappedAbstractDomain = MappedAbstractDomain;
-/**
- * A mutable version of the {@link MappedAbstractDomain} with {@link MutableMappedAbstractDomain#set|`set`} and {@link MutableMappedAbstractDomain#remove|`remove`}.
- */
-class MutableMappedAbstractDomain extends MappedAbstractDomain {
-    create(value) {
-        return new MutableMappedAbstractDomain(value);
-    }
-    set(key, value) {
-        super.set(key, value);
-    }
-    remove(key) {
-        super.remove(key);
-    }
-}
-exports.MutableMappedAbstractDomain = MutableMappedAbstractDomain;
-//# sourceMappingURL=mapped-abstract-domain.js.map