@eagleoutice/flowr 2.7.6 → 2.8.0

package/util/r-license.js

@@ -1,16 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRLicense = parseRLicense;
-const semver_1 = require("semver");
+exports.stringifyRLicense = stringifyRLicense;
 const assert_1 = require("./assert");
 const objects_1 = require("./objects");
+const r_version_1 = require("./r-version");
 /**
  * Parses an R license string into its structured representation.
  */
 function parseRLicense(licenseString) {
-    const start = skipWhitespace({ position: 0, remInput: licenseString });
-    const parsed = parseLicenseInfo(start);
-    return parsed.element;
+    return parseLicenseInfo(skipWhitespace({ position: 0, remInput: licenseString })).element;
+}
+/**
+ * Stringifies an R license element back into its string representation.
+ */
+function stringifyRLicense(license) {
+    const t = license.type;
+    switch (t) {
+        case 'no-license':
+            return 'NO LICENSE';
+        case 'license':
+            return license.versionConstraint ? `${license.license} (${license.versionConstraint.raw})` : license.license;
+        case 'exception':
+            return `with ${license.exception}`;
+        case 'combination': {
+            const left = stringifyRLicense(license.elements[0]);
+            const right = stringifyRLicense(license.elements[1]);
+            const leftStr = license.elements[0].type === 'combination' ? `(${left})` : left;
+            const rightStr = license.elements[1].type === 'combination' ? `(${right})` : right;
+            return `${leftStr} ${license.combination} ${rightStr}`;
+        }
+        default:
+            (0, assert_1.assertUnreachable)(t);
+    }
 }
 function parseLicenseInfo(info) {
     info = skipWhitespace(info);
@@ -72,8 +94,7 @@ function consumeLicenseName(info) {
 }
 function makeRange(rangeStr) {
     try {
-        rangeStr = rangeStr.trim().replaceAll('==', '=');
-        return new semver_1.Range(rangeStr);
+        return (0, r_version_1.parseRRange)(rangeStr);
     }
     catch {
         return undefined;

package/util/r-version.d.ts

@@ -0,0 +1,19 @@
+import { Range, SemVer } from 'semver';
+/**
+ * This parses an R version string and returns a SemVer object.
+ * In contrast to just using `new SemVer(version)`, this function also tries to
+ * normalize R's much free-er versioning scheme into valid SemVer versions.
+ * You can always access the original version string via the `str` property on the returned object.
+ */
+export declare function parseRVersion(version: string): SemVer & {
+    str: string;
+};
+/**
+ * This parses an R version range string and returns a SemVer Range object.
+ * In contrast to just using `new Range(range)`, this function also tries to
+ * normalize R's much free-er versioning scheme into valid SemVer ranges.
+ * You can always access the original range string via the `str` property on the returned object.
+ */
+export declare function parseRRange(range: string): Range & {
+    str: string;
+};

package/util/r-version.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRVersion = parseRVersion;
+exports.parseRRange = parseRRange;
+const semver_1 = require("semver");
+const assert_1 = require("./assert");
+function makeVersion(version, original) {
+    const semver = new semver_1.SemVer(version);
+    semver.str = original;
+    return semver;
+}
+/**
+ * Additionally, this transforms `a-b.c` into `a.0.0-b.c` and `a.b-c.d` into `a.b.0-c.d` to
+ * ensure valid SemVer format.
+ */
+function normalizeTooShortVersions(versions) {
+    const TooShortVersionRegex = /(^|(?<=[^\d.-]))(?<major>\d+)(\.(?<minor>\d+))?\.?-(?<prerelease>[0-9A-Za-z-.]+)(\s|$)/g;
+    let newVersions = '';
+    let match;
+    while ((match = TooShortVersionRegex.exec(versions)) !== null) {
+        const { major, minor, prerelease } = match.groups;
+        const prefix = versions.slice(0, match.index);
+        let newVersion = '';
+        if (minor === undefined) {
+            // only major version present
+            newVersion = `${major}.0.0-${prerelease}`;
+        }
+        else {
+            // major and minor version present, but dot before prerelease
+            newVersion = `${major}.${minor}.0-${prerelease}`;
+        }
+        newVersions += `${prefix}${newVersion}`;
+        versions = versions.slice(match.index + match[0].length);
+    }
+    newVersions += versions; // append any remaining part
+    return newVersions;
+}
+/**
+ * For every version `a.b.c.d.e...` converts it to `a.b.c-d.e...`
+ * If the version already contains a prerelease part, it is appended:
+ * `a.b.c.d.e-prerelease...` becomes `a.b.c-d.e-prerelease...`
+ */
+function normalizeAdditionalVersionsToPrerelease(version) {
+    version = normalizeTooShortVersions(version);
+    const AdditionalVersionRegex = /(\d+\.\d+\.\d+)(?<additional>(\.\d+)+)(-(?<prerelease>[0-9A-Za-z-.]+))?/g;
+    let match;
+    let newVersion = '';
+    // repeat until no more matches
+    while ((match = AdditionalVersionRegex.exec(version)) !== null) {
+        // append to new version, first take over anything before the match
+        const prefix = version.slice(0, match.index);
+        const { additional, prerelease } = match.groups;
+        const additionalParts = additional.slice(1).split('.'); // remove leading dot and split
+        if (additionalParts.length === 0) {
+            continue; // nothing to do
+        }
+        let newPrerelease = additionalParts.join('.');
+        if (prerelease) {
+            newPrerelease = `${newPrerelease}-${prerelease}`;
+        }
+        newVersion = `${prefix}${match[1]}-${newPrerelease}`;
+        version = version.slice(match.index + match[0].length);
+    }
+    newVersion += version; // append any remaining part
+    return newVersion;
+}
+/**
+ * This parses an R version string and returns a SemVer object.
+ * In contrast to just using `new SemVer(version)`, this function also tries to
+ * normalize R's much free-er versioning scheme into valid SemVer versions.
+ * You can always access the original version string via the `str` property on the returned object.
+ */
+function parseRVersion(version) {
+    try {
+        return makeVersion(version, version);
+    }
+    catch { /* do nothing */ }
+    try {
+        const normalized = normalizeAdditionalVersionsToPrerelease(version);
+        return makeVersion(normalized, version);
+    }
+    catch { /* do nothing */ }
+    const coerced = (0, semver_1.coerce)(version, { loose: true, includePrerelease: true });
+    (0, assert_1.guard)(coerced !== null, `Could not coerce R version "${version}" to SemVer`);
+    return makeVersion(coerced.version, version);
+}
+function makeRange(range, original) {
+    const semverRange = new semver_1.Range(range);
+    semverRange.str = original;
+    return semverRange;
+}
+/**
+ * This parses an R version range string and returns a SemVer Range object.
+ * In contrast to just using `new Range(range)`, this function also tries to
+ * normalize R's much free-er versioning scheme into valid SemVer ranges.
+ * You can always access the original range string via the `str` property on the returned object.
+ */
+function parseRRange(range) {
+    try {
+        return makeRange(range, range);
+    }
+    catch { /* try to normalize R range to SemVer */ }
+    const normalized = normalizeAdditionalVersionsToPrerelease(range);
+    return makeRange(normalized.replace(/==/g, '='), range);
+}
+//# sourceMappingURL=r-version.js.map

package/util/range.d.ts

@@ -43,6 +43,10 @@ export declare function getRangeEnd(p: SourceRange | undefined): SourcePosition
  * @param ec - end column
  */
 export declare function rangeFrom(sl: number | string, sc: number | string, el: number | string, ec: number | string): SourceRange;
+/**
+ * @returns an invalid source range
+ */
+export declare function invalidRange(): SourceRange;
 /**
  * Merges multiple source ranges into a single source range that spans from the earliest start to the latest end.
  * If you are interested in combining overlapping ranges into a minimal set of ranges, see {@link combineRanges}.
@@ -75,3 +79,5 @@ export declare function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec]: SourceRange, [
  * If you are interested in merging overlapping ranges, see {@link mergeRanges}.
  */
 export declare function combineRanges(...ranges: SourceRange[]): SourceRange[];
+/** A source location consisting of a source range and an optional file name. */
+export type SourceLocation = [...r: SourceRange, f?: string];

package/util/range.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRangeStart = getRangeStart;
 exports.getRangeEnd = getRangeEnd;
 exports.rangeFrom = rangeFrom;
+exports.invalidRange = invalidRange;
 exports.mergeRanges = mergeRanges;
 exports.rangeStartsCompletelyBefore = rangeStartsCompletelyBefore;
 exports.rangesOverlap = rangesOverlap;
@@ -33,6 +34,12 @@ function getRangeEnd(p) {
 function rangeFrom(sl, sc, el, ec) {
     return [Number(sl), Number(sc), Number(el), Number(ec)];
 }
+/**
+ * @returns an invalid source range
+ */
+function invalidRange() {
+    return [-1, -1, -1, -1];
+}
 /**
  * Merges multiple source ranges into a single source range that spans from the earliest start to the latest end.
  * If you are interested in combining overlapping ranges into a minimal set of ranges, see {@link combineRanges}.

package/util/simple-df/dfg-ascii.js

@@ -88,8 +88,8 @@ function dfgToAscii(dfg) {
         }
         g.setNode(String(id), {
             label,
-            width: Math.max(3, label.length * 2),
-            height: 3,
+            width: Math.max(3, label.length * 1.2),
+            height: 4,
             shape: 'rectangle'
         });
     }

package/util/text/args.d.ts

@@ -14,3 +14,12 @@
  * @param split       - The character or character sequence to split on (can not be backslash or quote!)
  */
 export declare function splitAtEscapeSensitive(inputString: string, escapeQuote?: boolean, split?: RegExp | string): string[];
+/**
+ * Splits the given string on 'and', but only if not nested inside `<>`, `[]`, `()`, or quotes.
+ * This also handles escaped quotes.
+ * @param str - The string to split
+ * @param splitOn - The string to split on (default: 'and')
+ * @param closes - The matching of closing characters for nesting, structures with different open and close characters only can be nested
+ *                 of each other, while those with the same open and close character (like quotes) can not be nested inside themselves.
+ */
+export declare function splitOnNestingSensitive(str: string, splitOn?: string, closes?: Record<string, string>): string[];

package/util/text/args.js

@@ -5,6 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitAtEscapeSensitive = splitAtEscapeSensitive;
+exports.splitOnNestingSensitive = splitOnNestingSensitive;
 /**
  * This splits an input string on the given split string (e.g., ` `), but checks if the string is quoted or escaped.
  *
@@ -81,4 +82,68 @@ function splitAtEscapeSensitive(inputString, escapeQuote = true, split = ' ') {
     }
     return args;
 }
+const MatchingClose = {
+    '<': '>',
+    '[': ']',
+    '(': ')',
+    '"': '"',
+    "'": "'"
+};
+/**
+ * Splits the given string on 'and', but only if not nested inside `<>`, `[]`, `()`, or quotes.
+ * This also handles escaped quotes.
+ * @param str - The string to split
+ * @param splitOn - The string to split on (default: 'and')
+ * @param closes - The matching of closing characters for nesting, structures with different open and close characters only can be nested
+ *                 of each other, while those with the same open and close character (like quotes) can not be nested inside themselves.
+ */
+function splitOnNestingSensitive(str, splitOn = 'and', closes = MatchingClose) {
+    const result = [];
+    const openCloseSame = new Set(Object.entries(closes).filter(([open, close]) => open === close).map(([open]) => open));
+    let current = '';
+    const nestStack = [];
+    for (let i = 0; i < str.length; i++) {
+        const c = str[i];
+        if (c === '\\' && i + 1 < str.length) {
+            // skip escaped characters
+            current += c + str[i + 1];
+            i++;
+        }
+        else if (nestStack.length > 0) {
+            if (!openCloseSame.has(c) && c in closes) {
+                // opening a new nest
+                nestStack.push(c);
+            }
+            else {
+                const top = nestStack[nestStack.length - 1];
+                if (c === closes[top]) {
+                    nestStack.pop();
+                }
+            }
+            current += c;
+        }
+        else {
+            if (c in closes) {
+                nestStack.push(c);
+                current += c;
+                continue;
+            }
+            // check for 'and' split
+            if (str.slice(i, i + splitOn.length) === splitOn &&
+                (i === 0 || /\s/.test(str[i - 1])) &&
+                (i + splitOn.length >= str.length || /\s/.test(str[i + splitOn.length]))) {
+                // split here
+                result.push(current.trim());
+                current = '';
+                i += splitOn.length - 1;
+                continue;
+            }
+            current += c;
+        }
+    }
+    if (current.trim().length > 0) {
+        result.push(current.trim());
+    }
+    return result;
+}
 //# sourceMappingURL=args.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.7.6';
+const version = '2.8.0';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */