@nfdi4plants/arctrl 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/ts/node_modules/@fable-org/fable-library-js/Option.js

@@ -0,0 +1,65 @@
+import { structuralHash, equals, compare } from './Util.js';
+
+// Using a class here for better compatibility with TS files importing Some
+class Some {
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+    // Don't add "Some" for consistency with erased options
+    toString() {
+        return String(this.value);
+    }
+    GetHashCode() {
+        return structuralHash(this.value);
+    }
+    Equals(other) {
+        if (other == null) {
+            return false;
+        }
+        else {
+            return equals(this.value, other instanceof Some ? other.value : other);
+        }
+    }
+    CompareTo(other) {
+        if (other == null) {
+            return 1;
+        }
+        else {
+            return compare(this.value, other instanceof Some ? other.value : other);
+        }
+    }
+}
+function value(x) {
+    if (x == null) {
+        throw new Error("Option has no value");
+    }
+    else {
+        return x instanceof Some ? x.value : x;
+    }
+}
+function unwrap(opt) {
+    return opt instanceof Some ? opt.value : opt;
+}
+function some(x) {
+    return x == null || x instanceof Some ? new Some(x) : x;
+}
+function toArray(opt) {
+    return (opt == null) ? [] : [value(opt)];
+}
+function defaultArg(opt, defaultValue) {
+    return (opt != null) ? value(opt) : defaultValue;
+}
+function defaultArgWith(opt, defThunk) {
+    return (opt != null) ? value(opt) : defThunk();
+}
+function map(mapping, opt) {
+    return (opt != null) ? some(mapping(value(opt))) : undefined;
+}
+function bind(binder, opt) {
+    return opt != null ? binder(value(opt)) : undefined;
+}
+
+export { Some, bind, defaultArg, defaultArgWith, map, some, toArray, unwrap, value };

package/dist/ts/node_modules/@fable-org/fable-library-js/Range.js

@@ -0,0 +1,23 @@
+import { compare } from './Util.js';
+import { delay, unfold } from './Seq.js';
+
+function makeRangeStepFunction(step, stop, zero, add) {
+    const stepComparedWithZero = compare(step, zero) | 0;
+    if (stepComparedWithZero === 0) {
+        throw new Error("The step of a range cannot be zero");
+    }
+    const stepGreaterThanZero = stepComparedWithZero > 0;
+    return (x) => {
+        const comparedWithLast = compare(x, stop) | 0;
+        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : (!stepGreaterThanZero && (comparedWithLast >= 0))) ? [x, add(x, step)] : undefined;
+    };
+}
+function integralRangeStep(start, step, stop, zero, add) {
+    const stepFn = makeRangeStepFunction(step, stop, zero, add);
+    return delay(() => unfold(stepFn, start));
+}
+function rangeDouble(start, step, stop) {
+    return integralRangeStep(start, step, stop, 0, (x, y) => (x + y));
+}
+
+export { integralRangeStep, makeRangeStepFunction, rangeDouble };

package/dist/ts/node_modules/@fable-org/fable-library-js/Reflection.js

@@ -0,0 +1,111 @@
+import { stringHash, combineHashCodes, equalArraysWith } from './Util.js';
+
+class CaseInfo {
+    constructor(declaringType, tag, name, fields) {
+        this.declaringType = declaringType;
+        this.tag = tag;
+        this.name = name;
+        this.fields = fields;
+    }
+}
+class TypeInfo {
+    constructor(fullname, generics, construct, parent, fields, cases, enumCases) {
+        this.fullname = fullname;
+        this.generics = generics;
+        this.construct = construct;
+        this.parent = parent;
+        this.fields = fields;
+        this.cases = cases;
+        this.enumCases = enumCases;
+    }
+    toString() {
+        return fullName(this);
+    }
+    GetHashCode() {
+        return getHashCode(this);
+    }
+    Equals(other) {
+        return equals(this, other);
+    }
+}
+function getGenerics(t) {
+    return t.generics != null ? t.generics : [];
+}
+function getHashCode(t) {
+    const fullnameHash = stringHash(t.fullname);
+    const genHashes = getGenerics(t).map(getHashCode);
+    return combineHashCodes([fullnameHash, ...genHashes]);
+}
+function equals(t1, t2) {
+    if (t1.fullname === "") { // Anonymous records
+        return t2.fullname === ""
+            && equalArraysWith(getRecordElements(t1), getRecordElements(t2), ([k1, v1], [k2, v2]) => k1 === k2 && equals(v1, v2));
+    }
+    else {
+        return t1.fullname === t2.fullname
+            && equalArraysWith(getGenerics(t1), getGenerics(t2), equals);
+    }
+}
+function class_type(fullname, generics, construct, parent) {
+    return new TypeInfo(fullname, generics, construct, parent);
+}
+function union_type(fullname, generics, construct, cases) {
+    const t = new TypeInfo(fullname, generics, construct, undefined, undefined, () => {
+        const caseNames = construct.prototype.cases();
+        return cases().map((fields, i) => new CaseInfo(t, i, caseNames[i], fields));
+    });
+    return t;
+}
+const string_type = new TypeInfo("System.String");
+function name(info) {
+    if (Array.isArray(info)) {
+        return info[0];
+    }
+    else if (info instanceof TypeInfo) {
+        const elemType = getElementType(info);
+        if (elemType != null) {
+            return name(elemType) + "[]";
+        }
+        else {
+            const i = info.fullname.lastIndexOf(".");
+            return i === -1 ? info.fullname : info.fullname.substr(i + 1);
+        }
+    }
+    else {
+        return info.name;
+    }
+}
+function fullName(t) {
+    const elemType = getElementType(t);
+    if (elemType != null) {
+        return fullName(elemType) + "[]";
+    }
+    else if (t.generics == null || t.generics.length === 0) {
+        return t.fullname;
+    }
+    else {
+        return t.fullname + "[" + t.generics.map((x) => fullName(x)).join(",") + "]";
+    }
+}
+function getElementType(t) {
+    return t.fullname === "[]" && t.generics?.length === 1 ? t.generics[0] : undefined;
+}
+// FSharpType
+function getUnionCases(t) {
+    if (t.cases != null) {
+        return t.cases();
+    }
+    else {
+        throw new Error(`${t.fullname} is not an F# union type`);
+    }
+}
+function getRecordElements(t) {
+    if (t.fields != null) {
+        return t.fields();
+    }
+    else {
+        throw new Error(`${t.fullname} is not an F# record type`);
+    }
+}
+
+export { CaseInfo, TypeInfo, class_type, equals, fullName, getElementType, getGenerics, getHashCode, getRecordElements, getUnionCases, name, string_type, union_type };

package/dist/ts/node_modules/@fable-org/fable-library-js/RegExp.js

@@ -0,0 +1,114 @@
+function create(pattern, options = 0) {
+    // Supported RegexOptions
+    // * IgnoreCase:  0x0001
+    // * Multiline:   0x0002
+    // * Compiled:    0x0008 (ignored)
+    // * Singleline:  0x0010
+    // * ECMAScript:  0x0100 (ignored)
+    if ((options & -284) !== 0) {
+        throw new Error("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
+    }
+    // Set always global and unicode flags for compatibility with dotnet, see #2925
+    let flags = "gu";
+    flags += options & 1 ? "i" : ""; // 0x0001 RegexOptions.IgnoreCase
+    flags += options & 2 ? "m" : "";
+    flags += options & 16 ? "s" : "";
+    return new RegExp(pattern, flags);
+}
+// From http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
+function escape(str) {
+    return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+}
+function isMatch(reg, input, startAt = 0) {
+    reg.lastIndex = startAt;
+    return reg.test(input);
+}
+function match(reg, input, startAt = 0) {
+    reg.lastIndex = startAt;
+    return reg.exec(input);
+}
+function matches(reg, input, startAt = 0) {
+    if (input == null) {
+        throw new Error("Input cannot ve null");
+    }
+    if (!reg.global) {
+        throw new Error("Non-global RegExp"); // Prevent infinite loop
+    }
+    reg.lastIndex = startAt;
+    const matches = [];
+    let m;
+    let lastMatchIndex = -1;
+    while ((m = reg.exec(input)) != null) {
+        // It can happen even global regex get stuck, see #2845
+        if (m.index === lastMatchIndex) {
+            reg.lastIndex++;
+        }
+        else {
+            lastMatchIndex = m.index;
+            matches.push(m);
+        }
+    }
+    return matches;
+}
+function replace(reg, input, replacement, limit, offset = 0) {
+    function replacer() {
+        let res = arguments[0];
+        if (limit) {
+            limit--;
+            const match = [];
+            const len = arguments.length;
+            // arguments: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_function_as_a_parameter
+            // * match: matched substring
+            // * p1, p2, ...: nth capture group string
+            // * offset: offset of matched substring
+            // * string: whole string examined
+            // * groups: named capturing groups
+            //           ONLY if regex contains a named capture group AND browser supports named groups
+            // -> last element can be groups OR input string
+            // -> check if last element is string
+            const withGroups = typeof arguments[len - 1] !== "string";
+            let pLast = withGroups ? len - 3 : len - 2;
+            for (let i = 0; i < pLast; i++) {
+                match.push(arguments[i]);
+            }
+            match.index = arguments[pLast++];
+            match.input = arguments[pLast++];
+            if (withGroups) {
+                match.groups = arguments[pLast];
+            }
+            res = replacement(match);
+        }
+        return res;
+    }
+    if (typeof reg === "string") {
+        const tmp = reg;
+        reg = create(input, limit ?? 0);
+        input = tmp;
+        limit = undefined;
+    }
+    if (typeof replacement === "function") {
+        limit = limit == null ? -1 : limit;
+        return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);
+    }
+    else {
+        replacement =
+            replacement
+                // $0 doesn't work with JS regex, see #1155
+                .replace(/\$0/g, (_s) => "$&")
+                // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)
+                .replace(/\${([^}]+)}/g, "\$<$1>");
+        if (limit != null) {
+            let m;
+            const sub1 = input.substring(offset);
+            const _matches = matches(reg, sub1);
+            const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;
+            return input.substring(0, offset) + sub2.replace(reg, replacement)
+                + input.substring(offset + sub2.length);
+        }
+        else {
+            return input.replace(reg, replacement);
+        }
+    }
+}
+
+export { create, escape, isMatch, match, matches, replace };

package/dist/ts/node_modules/@fable-org/fable-library-js/Result.js

@@ -0,0 +1,36 @@
+import { Union } from './Types.js';
+
+function FSharpResult$2_Ok(ResultValue) {
+    return new FSharpResult$2(0, [ResultValue]);
+}
+function FSharpResult$2_Error(ErrorValue) {
+    return new FSharpResult$2(1, [ErrorValue]);
+}
+class FSharpResult$2 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Ok", "Error"];
+    }
+}
+function Result_Map(mapping, result) {
+    if (result.tag === /* Ok */ 0) {
+        return FSharpResult$2_Ok(mapping(result.fields[0]));
+    }
+    else {
+        return FSharpResult$2_Error(result.fields[0]);
+    }
+}
+function Result_MapError(mapping, result) {
+    if (result.tag === /* Ok */ 0) {
+        return FSharpResult$2_Ok(result.fields[0]);
+    }
+    else {
+        return FSharpResult$2_Error(mapping(result.fields[0]));
+    }
+}
+
+export { FSharpResult$2, FSharpResult$2_Error, FSharpResult$2_Ok, Result_Map, Result_MapError };