@eagleoutice/flowr 2.1.10 → 2.1.12

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generators = void 0;
+exports.getGenerator = getGenerator;
+const flowr_search_1 = require("../flowr-search");
+const parse_1 = require("../../slicing/criterion/parse");
+const assert_1 = require("../../util/assert");
+/**
+ * All supported generators!
+ */
+exports.generators = {
+    all: generateAll,
+    get: generateGet,
+    criterion: generateCriterion,
+    from: generateFrom
+};
+function generateAll(data) {
+    return new flowr_search_1.FlowrSearchElements(getAllNodes(data)
+        .map(node => ({ node })));
+}
+function getAllNodes(data) {
+    return [...new Map([...data.normalize.idMap.values()].map(n => [n.info.id, n]))
+            .values()];
+}
+function generateGet(data, { filter: { line, column, id, name, nameIsRegex } }) {
+    let potentials = (id ?
+        [data.normalize.idMap.get(id)].filter(assert_1.isNotUndefined) :
+        getAllNodes(data));
+    if (line && line < 0) {
+        const maxLines = data.normalize.ast.info.fullRange?.[2] ??
+            (id ? getAllNodes(data) : potentials).reduce((maxLine, { location }) => location && location[2] > maxLine ? location[2] : maxLine, 0);
+        line = maxLines + line + 1;
+    }
+    if (line && column) {
+        potentials = potentials.filter(({ location }) => location?.[0] === line && location?.[1] === column);
+    }
+    else if (line) {
+        potentials = potentials.filter(({ location }) => location?.[0] === line);
+    }
+    else if (column) {
+        potentials = potentials.filter(({ location }) => location?.[1] === column);
+    }
+    if (nameIsRegex && name) {
+        const nameFilter = new RegExp(name);
+        potentials = potentials.filter(({ lexeme }) => lexeme && nameFilter.test(lexeme));
+    }
+    else if (name) {
+        potentials = potentials.filter(({ lexeme }) => lexeme === name);
+    }
+    return new flowr_search_1.FlowrSearchElements(potentials.map(node => ({ node })));
+}
+function generateFrom(data, args) {
+    return new flowr_search_1.FlowrSearchElements(Array.isArray(args.from) ? args.from : [args.from]);
+}
+function generateCriterion(data, args) {
+    return new flowr_search_1.FlowrSearchElements(args.criterion.map(c => ({ node: data.normalize.idMap.get((0, parse_1.slicingCriterionToId)(c, data.normalize.idMap)) })));
+}
+function getGenerator(name) {
+    if (!exports.generators[name]) {
+        throw new Error(`Unknown generator: ${name}`);
+    }
+    return exports.generators[name];
+}
+//# sourceMappingURL=search-generators.js.map

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

@@ -0,0 +1,57 @@
+import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchInput, FlowrSearchTransformerNodeBase } from '../flowr-search';
+import type { Pipeline } from '../../core/steps/pipeline/pipeline';
+import type { LastOfArray, Tail2TypesOrUndefined, TailOfArray } from '../../util/arrays';
+import type { FlowrFilterExpression } from '../flowr-search-filters';
+import type { FlowrSearchGeneratorNode } from './search-generators';
+import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * This is a union of all possible transformer node types
+ */
+export type FlowrSearchTransformerNode = {
+    [K in TransformerNames]: FlowrSearchTransformerNodeBase<K, Tail2TypesOrUndefined<Parameters<typeof transformers[K]>>>;
+}[TransformerNames];
+export type TransformerNames = keyof typeof transformers;
+export type GetTransformer<Name extends TransformerNames> = FlowrSearchTransformerNode & {
+    name: Name;
+};
+export type GetOutputOfTransformer<Name extends TransformerNames> = ReturnType<typeof transformers[Name]>;
+/**
+ * All supported generators!
+ */
+export declare const transformers: {
+    readonly first: typeof getFirst;
+    readonly last: typeof getLast;
+    readonly index: typeof getIndex;
+    readonly tail: typeof getTail;
+    readonly take: typeof getTake;
+    readonly skip: typeof getSkip;
+    readonly filter: typeof getFilter;
+    readonly merge: typeof getMerge;
+    readonly select: typeof getSelect;
+};
+export declare function getTransformer<Name extends TransformerNames>(name: Name): typeof transformers[Name];
+/** If we already have no more elements, cascade will not add any but keep the empty elements, otherwise it will now be NewElements */
+type CascadeEmpty<Elements extends FlowrSearchElement<ParentInformation>[], NewElements extends FlowrSearchElement<ParentInformation>[]> = Elements extends [] ? FlowrSearchElements<ParentInformation, []> : FlowrSearchElements<ParentInformation, NewElements>;
+declare function getFirst<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, [Elements[0]]>;
+declare function getLast<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, [LastOfArray<Elements>]>;
+declare function getIndex<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { index }: {
+    index: number;
+}): CascadeEmpty<Elements, [Elements[number]]>;
+declare function getSelect<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { select }: {
+    select: number[];
+}): CascadeEmpty<Elements, Elements>;
+declare function getTail<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, TailOfArray<Elements>>;
+declare function getTake<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { count }: {
+    count: number;
+}): CascadeEmpty<Elements, TailOfArray<Elements>>;
+declare function getSkip<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { count }: {
+    count: number;
+}): CascadeEmpty<Elements, TailOfArray<Elements>>;
+declare function getFilter<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { filter }: {
+    filter: FlowrFilterExpression;
+}): CascadeEmpty<Elements, Elements | []>;
+declare function getMerge<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, other: {
+    search: unknown[];
+    generator: FlowrSearchGeneratorNode;
+}): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
+export {};

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformers = void 0;
+exports.getTransformer = getTransformer;
+const flowr_search_filters_1 = require("../flowr-search-filters");
+const flowr_search_executor_1 = require("../flowr-search-executor");
+const assert_1 = require("../../util/assert");
+/**
+ * All supported generators!
+ */
+exports.transformers = {
+    first: getFirst,
+    last: getLast,
+    index: getIndex,
+    tail: getTail,
+    take: getTake,
+    skip: getSkip,
+    filter: getFilter,
+    merge: getMerge,
+    select: getSelect
+};
+function getTransformer(name) {
+    if (!exports.transformers[name]) {
+        throw new Error(`Unknown transformer: ${name}`);
+    }
+    return exports.transformers[name];
+}
+function compareByLocation({ node: a }, { node: b }) {
+    if (a.location && b.location) {
+        return a.location[0] - b.location[0] || a.location[1] - b.location[1];
+    }
+    else if (a.location) {
+        return -1;
+    }
+    return b.location ? 1 : 0;
+}
+function getFirstByLocation(elements) {
+    if (elements.length === 0) {
+        return undefined;
+    }
+    return elements.reduce((acc, cur) => {
+        if (acc === undefined) {
+            return cur;
+        }
+        return compareByLocation(acc, cur) < 0 ? acc : cur;
+    }, undefined);
+}
+/* later we can add something like sort partially to get the first k elements */
+function sortFully(elements) {
+    return elements.sort(compareByLocation);
+}
+function getLastByLocation(elements) {
+    if (elements.length === 0) {
+        return undefined;
+    }
+    return elements.reduce((acc, cur) => {
+        if (acc === undefined) {
+            return cur;
+        }
+        return compareByLocation(acc, cur) > 0 ? acc : cur;
+    }, undefined);
+}
+function getFirst(data, elements) {
+    return elements.mutate(e => [getFirstByLocation(e)]);
+}
+function getLast(data, elements) {
+    return elements.mutate(e => [getLastByLocation(e)]);
+}
+function getIndex(data, elements, { index }) {
+    return elements.mutate(e => [sortFully(e)[index]]);
+}
+function getSelect(data, elements, { select }) {
+    return elements.mutate(e => {
+        sortFully(e);
+        return select.map(i => e[i]).filter(assert_1.isNotUndefined);
+    });
+}
+function getTail(data, elements) {
+    return elements.mutate(e => {
+        const first = getFirstByLocation(e);
+        return e.filter(el => el !== first);
+    });
+}
+function getTake(data, elements, { count }) {
+    return elements.mutate(e => sortFully(e).slice(0, count));
+}
+function getSkip(data, elements, { count }) {
+    return elements.mutate(e => sortFully(e).slice(count));
+}
+function getFilter(data, elements, { filter }) {
+    return elements.mutate(e => e.filter(({ node }) => (0, flowr_search_filters_1.evalFilter)(filter, { node, normalize: data.normalize, dataflow: data.dataflow })));
+}
+function getMerge(
+/* search has to be unknown because it is a recursive type */
+data, elements, other) {
+    const resultOther = (0, flowr_search_executor_1.runSearch)(other, data);
+    return elements.addAll(resultOther);
+}
+//# sourceMappingURL=search-transformer.js.map

package/search/search-optimizer/search-optimizer.d.ts

@@ -0,0 +1,9 @@
+import type { FlowrSearchGeneratorNode, GeneratorNames } from '../search-executor/search-generators';
+import type { FlowrSearchTransformerNode, TransformerNames } from '../search-executor/search-transformer';
+import type { FlowrSearch } from '../flowr-search-builder';
+import type { FlowrSearchElement, FlowrSearchElements } from '../flowr-search';
+/**
+ * Optimizations are currently not reflected
+ * in an update of the search object.
+ */
+export declare function optimize<Info, Generator extends GeneratorNames, Transformers extends TransformerNames[], ElementType extends FlowrSearchElements<Info, FlowrSearchElement<Info>[]>>(generator: FlowrSearchGeneratorNode, search: readonly FlowrSearchTransformerNode[]): FlowrSearch<Info, Generator, Transformers, ElementType>;

package/search/search-optimizer/search-optimizer.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimize = optimize;
+function fingerPrintTransformer(transformer) {
+    return JSON.stringify(transformer);
+}
+/**
+ * Optimizations are currently not reflected
+ * in an update of the search object.
+ */
+function optimize(generator, search) {
+    let searchToOptimize = search.slice();
+    let fingerprint = fingerPrintTransformer(searchToOptimize);
+    generator = optimizeGenerator(generator);
+    let lastFingerprint = '{}';
+    /* maybe we want shared optimizers in the future, but for now we let it be :sparkles: */
+    while (fingerprint !== lastFingerprint) {
+        lastFingerprint = fingerprint;
+        searchToOptimize = optimizeSearch(searchToOptimize, generator);
+        fingerprint = fingerPrintTransformer(searchToOptimize);
+    }
+    return {
+        generator,
+        search: searchToOptimize
+    };
+}
+function optimizeGenerator(generator) {
+    return dropAnyNameRegex(generator);
+}
+/*
+ * Ideas:
+ * Replace .tail().last() with .last()
+ * Replace .take(1) with '.first()'
+ * Remove duplicate indices in a .select
+ * Provide unification step after merge (id based)
+ * Install caches if sorting is required multiple times (especially for repeated use of generators)
+ */
+function optimizeSearch(search, _generator) {
+    search = dropDuplicateNoops(search);
+    search = selectWithSingleCanBeIndex(search);
+    return search;
+}
+const noopTransformers = new Set(['first', 'last']);
+/* yes we could optimize something like first, last, first too, but why bother :D*/
+function dropDuplicateNoops(transformers) {
+    const newTransformers = [];
+    let lastTransformer;
+    for (const transformer of transformers) {
+        if (lastTransformer === undefined || lastTransformer.name !== transformer.name || !noopTransformers.has(transformer.name)) {
+            newTransformers.push(transformer);
+        }
+        lastTransformer = transformer;
+    }
+    return newTransformers;
+}
+function selectWithSingleCanBeIndex(transformers) {
+    return transformers.map(transformer => {
+        if (transformer.name === 'select' && transformer.args.select.length === 1) {
+            return {
+                ...transformer,
+                name: 'index',
+                args: {
+                    index: transformer.args.select[0]
+                }
+            };
+        }
+        return transformer;
+    });
+}
+function dropAnyNameRegex(generator) {
+    if (generator.name !== 'get' || !generator.args.filter.nameIsRegex) {
+        return generator;
+    }
+    if (generator.args.filter.name === '.') {
+        return {
+            ...generator,
+            args: {
+                ...generator.args,
+                filter: {
+                    ...generator.args.filter,
+                    name: undefined,
+                    nameIsRegex: undefined
+                }
+            }
+        };
+    }
+    return generator;
+}
+//# sourceMappingURL=search-optimizer.js.map

package/util/arrays.d.ts

@@ -1,7 +1,20 @@
+import type { AnyArray, Tail } from 'ts-essentials';
 /**
  * Returns the tail of an array (all elements except the first one).
  */
 export type TailOfArray<T extends unknown[]> = T extends [infer _, ...infer Rest] ? Rest : never;
+/**
+ * Returns the union of types in an array, but the first one, uses U as a fallback if the array is empty.
+ */
+export type TailTypesOrUndefined<T extends AnyArray, U = undefined> = T extends [] ? U : T extends [unknown] ? U : Tail<T>[number];
+/**
+ * Returns the union of types in an array, but the first and the second one, uses U as a fallback if the array is empty.
+ */
+export type Tail2TypesOrUndefined<T extends AnyArray, U = undefined> = T extends [] ? U : T extends [unknown] ? U : T extends [unknown, unknown] ? U : Tail<Tail<T>>[number];
+/**
+ * Returns the last element of an array
+ */
+export type LastOfArray<T extends AnyArray> = T extends [...infer _, infer L] ? L : never;
 /**
  * Splits the array every time the given predicate fires.
  * The element the split appears on will not be included!

package/util/assert.d.ts

@@ -9,4 +9,4 @@ export type GuardMessage = string | (() => string);
  * @param message - if a string, we will use it as the error message, if it is a function, we will call it to produce the error message (can be used to avoid costly message generations)
  * @throws GuardError - if the assertion fails
  */
-export declare function guard(assertion: boolean | undefined, message?: GuardMessage): asserts assertion;
+export declare function guard(assertion: unknown | undefined, message?: GuardMessage): asserts assertion;

package/util/mermaid/mermaid.js

@@ -21,6 +21,23 @@ const replacements = {
     '&': '#38;',
     '\'': '#39;',
     ':': '#58;',
+    '∨': '#8744;',
+    '∧': '#8743;',
+    '¬': '#172;',
+    '→': '#8594;',
+    '↔': '#8596;',
+    '⇒': '#8658;',
+    '⇔': '#8660;',
+    '∀': '#8704;',
+    '∃': '#8707;',
+    '∈': '#8712;',
+    '∉': '#8713;',
+    '∋': '#8715;',
+    '∌': '#8716;',
+    '∩': '#8745;',
+    '∪': '#8746;',
+    '∫': '#8747;',
+    '⊕': '#8853;',
 };
 function escapeMarkdown(text) {
     for (const [key, value] of Object.entries(replacements)) {

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