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

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

@@ -0,0 +1,105 @@
+import { Union } from './Types.js';
+
+const CaseRules = {
+    None: 0,
+    LowerFirst: 1,
+    SnakeCase: 2,
+    SnakeCaseAllCaps: 3,
+    KebabCase: 4,
+};
+function dashify(str, separator) {
+    return str.replace(/[a-z]?[A-Z]/g, (m) => m.length === 1
+        ? m.toLowerCase()
+        : m.charAt(0) + separator + m.charAt(1).toLowerCase());
+}
+function changeCase(str, caseRule) {
+    switch (caseRule) {
+        case CaseRules.LowerFirst:
+            return str.charAt(0).toLowerCase() + str.slice(1);
+        case CaseRules.SnakeCase:
+            return dashify(str, "_");
+        case CaseRules.SnakeCaseAllCaps:
+            return dashify(str, "_").toUpperCase();
+        case CaseRules.KebabCase:
+            return dashify(str, "-");
+        case CaseRules.None:
+        default:
+            return str;
+    }
+}
+function keyValueList(fields, caseRule = CaseRules.None) {
+    const obj = {};
+    const definedCaseRule = caseRule;
+    function fail(kvPair) {
+        throw new Error("Cannot infer key and value of " + String(kvPair));
+    }
+    function assign(key, caseRule, value) {
+        key = changeCase(key, caseRule);
+        obj[key] = value;
+    }
+    for (let kvPair of fields) {
+        let caseRule = CaseRules.None;
+        if (kvPair == null) {
+            fail(kvPair);
+        }
+        // Deflate unions and use the defined case rule
+        if (kvPair instanceof Union) {
+            const name = kvPair.cases()[kvPair.tag];
+            kvPair = kvPair.fields.length === 0 ? name : [name].concat(kvPair.fields);
+            caseRule = definedCaseRule;
+        }
+        if (Array.isArray(kvPair)) {
+            switch (kvPair.length) {
+                case 0:
+                    fail(kvPair);
+                    break;
+                case 1:
+                    assign(kvPair[0], caseRule, true);
+                    break;
+                case 2:
+                    const value = kvPair[1];
+                    assign(kvPair[0], caseRule, value);
+                    break;
+                default:
+                    assign(kvPair[0], caseRule, kvPair.slice(1));
+            }
+        }
+        else if (typeof kvPair === "string") {
+            assign(kvPair, caseRule, true);
+        }
+        else {
+            fail(kvPair);
+        }
+    }
+    return obj;
+}
+function tryGetValue(map, key, defaultValue) {
+    if (map.has(key)) {
+        defaultValue.contents = map.get(key);
+        return true;
+    }
+    return false;
+}
+function addToSet(v, set) {
+    if (set.has(v)) {
+        return false;
+    }
+    set.add(v);
+    return true;
+}
+function addToDict(dict, k, v) {
+    if (dict.has(k)) {
+        throw new Error("An item with the same key has already been added. Key: " + k);
+    }
+    dict.set(k, v);
+}
+function getItemFromDict(map, key) {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    else {
+        throw new Error(`The given key '${key}' was not present in the dictionary.`);
+    }
+}
+
+export { addToDict, addToSet, getItemFromDict, keyValueList, tryGetValue };

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

@@ -0,0 +1,320 @@
+import { getEnumerator, disposeSafe, toIterator, equals, defaultOf } from './Util.js';
+import { concat, iterateIndexed, toArray, map, iterate, delay } from './Seq.js';
+import { value } from './Option.js';
+import { setItem } from './Array.js';
+import { FSharpRef } from './Types.js';
+import { getItemFromDict, tryGetValue } from './MapUtil.js';
+import { format } from './String.js';
+
+class Dictionary {
+    constructor(pairs, comparer) {
+        const this$ = new FSharpRef(defaultOf());
+        this.comparer = comparer;
+        this$.contents = this;
+        this.hashMap = (new Map([]));
+        this["init@9"] = 1;
+        const enumerator = getEnumerator(pairs);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const pair = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                Dictionary__Add_5BDDA1(this$.contents, pair[0], pair[1]);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return "Dictionary";
+    }
+    toJSON() {
+        const this$ = this;
+        return Array.from(this$);
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$);
+    }
+    GetEnumerator() {
+        const this$ = this;
+        return getEnumerator(concat(this$.hashMap.values()));
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.Generic.ICollection`1.Add2B595"(item) {
+        const this$ = this;
+        Dictionary__Add_5BDDA1(this$, item[0], item[1]);
+    }
+    "System.Collections.Generic.ICollection`1.Clear"() {
+        const this$ = this;
+        Dictionary__Clear(this$);
+    }
+    "System.Collections.Generic.ICollection`1.Contains2B595"(item) {
+        const this$ = this;
+        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);
+        let matchResult;
+        if (matchValue != null) {
+            if (equals(value(matchValue)[1], item[1])) {
+                matchResult = 0;
+                value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return true;
+            default:
+                return false;
+        }
+    }
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array, arrayIndex) {
+        const this$ = this;
+        iterateIndexed((i, e) => {
+            setItem(array, arrayIndex + i, e);
+        }, this$);
+    }
+    "System.Collections.Generic.ICollection`1.get_Count"() {
+        const this$ = this;
+        return Dictionary__get_Count(this$) | 0;
+    }
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"() {
+        return false;
+    }
+    "System.Collections.Generic.ICollection`1.Remove2B595"(item) {
+        const this$ = this;
+        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);
+        if (matchValue != null) {
+            if (equals(value(matchValue)[1], item[1])) {
+                Dictionary__Remove_2B595(this$, item[0]);
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    "System.Collections.Generic.IDictionary`2.Add5BDDA1"(key, value) {
+        const this$ = this;
+        Dictionary__Add_5BDDA1(this$, key, value);
+    }
+    "System.Collections.Generic.IDictionary`2.ContainsKey2B595"(key) {
+        const this$ = this;
+        return Dictionary__ContainsKey_2B595(this$, key);
+    }
+    "System.Collections.Generic.IDictionary`2.get_Item2B595"(key) {
+        const this$ = this;
+        return Dictionary__get_Item_2B595(this$, key);
+    }
+    "System.Collections.Generic.IDictionary`2.set_Item5BDDA1"(key, v) {
+        const this$ = this;
+        Dictionary__set_Item_5BDDA1(this$, key, v);
+    }
+    "System.Collections.Generic.IDictionary`2.get_Keys"() {
+        const this$ = this;
+        return toArray(delay(() => map((pair) => pair[0], this$)));
+    }
+    "System.Collections.Generic.IDictionary`2.Remove2B595"(key) {
+        const this$ = this;
+        return Dictionary__Remove_2B595(this$, key);
+    }
+    "System.Collections.Generic.IDictionary`2.TryGetValue6DC89625"(key, value$1) {
+        const this$ = this;
+        const matchValue = Dictionary__TryFind_2B595(this$, key);
+        if (matchValue != null) {
+            const pair = value(matchValue);
+            value$1.contents = pair[1];
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    "System.Collections.Generic.IDictionary`2.get_Values"() {
+        const this$ = this;
+        return toArray(delay(() => map((pair) => pair[1], this$)));
+    }
+    get size() {
+        const this$ = this;
+        return Dictionary__get_Count(this$) | 0;
+    }
+    clear() {
+        const this$ = this;
+        Dictionary__Clear(this$);
+    }
+    delete(k) {
+        const this$ = this;
+        return Dictionary__Remove_2B595(this$, k);
+    }
+    entries() {
+        const this$ = this;
+        return map((p) => [p[0], p[1]], this$);
+    }
+    get(k) {
+        const this$ = this;
+        return Dictionary__get_Item_2B595(this$, k);
+    }
+    has(k) {
+        const this$ = this;
+        return Dictionary__ContainsKey_2B595(this$, k);
+    }
+    keys() {
+        const this$ = this;
+        return map((p) => p[0], this$);
+    }
+    set(k, v) {
+        const this$ = this;
+        Dictionary__set_Item_5BDDA1(this$, k, v);
+        return this$;
+    }
+    values() {
+        const this$ = this;
+        return map((p) => p[1], this$);
+    }
+    forEach(f, thisArg) {
+        const this$ = this;
+        iterate((p) => {
+            f(p[1], p[0], this$);
+        }, this$);
+    }
+}
+function Dictionary__TryFindIndex_2B595(this$, k) {
+    const h = this$.comparer.GetHashCode(k) | 0;
+    let matchValue;
+    let outArg = defaultOf();
+    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg];
+    if (matchValue[0]) {
+        return [true, h, matchValue[1].findIndex((pair) => this$.comparer.Equals(k, pair[0]))];
+    }
+    else {
+        return [false, h, -1];
+    }
+}
+function Dictionary__TryFind_2B595(this$, k) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]];
+        default:
+            return undefined;
+    }
+}
+function Dictionary__Clear(this$) {
+    this$.hashMap.clear();
+}
+function Dictionary__get_Count(this$) {
+    let count = 0;
+    let enumerator = getEnumerator(this$.hashMap.values());
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const pairs = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            count = ((count + pairs.length) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return count | 0;
+}
+function Dictionary__get_Item_2B595(this$, k) {
+    const matchValue = Dictionary__TryFind_2B595(this$, k);
+    if (matchValue != null) {
+        return value(matchValue)[1];
+    }
+    else {
+        throw new Error("The item was not found in collection");
+    }
+}
+function Dictionary__set_Item_5BDDA1(this$, k, v) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]] = [k, v];
+        }
+        else {
+            void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));
+        }
+    }
+    else {
+        this$.hashMap.set(matchValue[1], [[k, v]]);
+    }
+}
+function Dictionary__Add_5BDDA1(this$, k, v) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            throw new Error(format("An item with the same key has already been added. Key: {0}", k));
+        }
+        else {
+            void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));
+        }
+    }
+    else {
+        this$.hashMap.set(matchValue[1], [[k, v]]);
+    }
+}
+function Dictionary__ContainsKey_2B595(this$, k) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return true;
+        default:
+            return false;
+    }
+}
+function Dictionary__Remove_2B595(this$, k) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);
+            return true;
+        }
+        default:
+            return false;
+    }
+}
+
+export { Dictionary, Dictionary__Add_5BDDA1, Dictionary__Clear, Dictionary__ContainsKey_2B595, Dictionary__Remove_2B595, Dictionary__TryFind_2B595, Dictionary__get_Count, Dictionary__get_Item_2B595, Dictionary__set_Item_5BDDA1 };

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

@@ -0,0 +1,204 @@
+import { getEnumerator, disposeSafe, toIterator, defaultOf } from './Util.js';
+import { concat, iterateIndexed, map, iterate } from './Seq.js';
+import { setItem } from './Array.js';
+import { FSharpRef } from './Types.js';
+import { getItemFromDict, tryGetValue } from './MapUtil.js';
+
+class HashSet {
+    constructor(items, comparer) {
+        const this$ = new FSharpRef(defaultOf());
+        this.comparer = comparer;
+        this$.contents = this;
+        this.hashMap = (new Map([]));
+        this["init@9"] = 1;
+        const enumerator = getEnumerator(items);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const item = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                HashSet__Add_2B595(this$.contents, item);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return "HashSet";
+    }
+    toJSON() {
+        const this$ = this;
+        return Array.from(this$);
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$);
+    }
+    GetEnumerator() {
+        const this$ = this;
+        return getEnumerator(concat(this$.hashMap.values()));
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.Generic.ICollection`1.Add2B595"(item) {
+        const this$ = this;
+        HashSet__Add_2B595(this$, item);
+    }
+    "System.Collections.Generic.ICollection`1.Clear"() {
+        const this$ = this;
+        HashSet__Clear(this$);
+    }
+    "System.Collections.Generic.ICollection`1.Contains2B595"(item) {
+        const this$ = this;
+        return HashSet__Contains_2B595(this$, item);
+    }
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array, arrayIndex) {
+        const this$ = this;
+        iterateIndexed((i, e) => {
+            setItem(array, arrayIndex + i, e);
+        }, this$);
+    }
+    "System.Collections.Generic.ICollection`1.get_Count"() {
+        const this$ = this;
+        return HashSet__get_Count(this$) | 0;
+    }
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"() {
+        return false;
+    }
+    "System.Collections.Generic.ICollection`1.Remove2B595"(item) {
+        const this$ = this;
+        return HashSet__Remove_2B595(this$, item);
+    }
+    get size() {
+        const this$ = this;
+        return HashSet__get_Count(this$) | 0;
+    }
+    add(k) {
+        const this$ = this;
+        HashSet__Add_2B595(this$, k);
+        return this$;
+    }
+    clear() {
+        const this$ = this;
+        HashSet__Clear(this$);
+    }
+    delete(k) {
+        const this$ = this;
+        return HashSet__Remove_2B595(this$, k);
+    }
+    has(k) {
+        const this$ = this;
+        return HashSet__Contains_2B595(this$, k);
+    }
+    keys() {
+        const this$ = this;
+        return map((x) => x, this$);
+    }
+    values() {
+        const this$ = this;
+        return map((x) => x, this$);
+    }
+    entries() {
+        const this$ = this;
+        return map((v) => [v, v], this$);
+    }
+    forEach(f, thisArg) {
+        const this$ = this;
+        iterate((x) => {
+            f(x, x, this$);
+        }, this$);
+    }
+}
+function HashSet__TryFindIndex_2B595(this$, k) {
+    const h = this$.comparer.GetHashCode(k) | 0;
+    let matchValue;
+    let outArg = defaultOf();
+    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg];
+    if (matchValue[0]) {
+        return [true, h, matchValue[1].findIndex((v_1) => this$.comparer.Equals(k, v_1))];
+    }
+    else {
+        return [false, h, -1];
+    }
+}
+function HashSet__Clear(this$) {
+    this$.hashMap.clear();
+}
+function HashSet__get_Count(this$) {
+    let count = 0;
+    let enumerator = getEnumerator(this$.hashMap.values());
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const items = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            count = ((count + items.length) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return count | 0;
+}
+function HashSet__Add_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            return false;
+        }
+        else {
+            void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));
+            return true;
+        }
+    }
+    else {
+        this$.hashMap.set(matchValue[1], [k]);
+        return true;
+    }
+}
+function HashSet__Contains_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return true;
+        default:
+            return false;
+    }
+}
+function HashSet__Remove_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);
+            return true;
+        }
+        default:
+            return false;
+    }
+}
+
+export { HashSet, HashSet__Add_2B595, HashSet__Clear, HashSet__Contains_2B595, HashSet__Remove_2B595, HashSet__get_Count };

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

@@ -0,0 +1,10 @@
+function Helpers_allocateArrayFromCons(cons, len) {
+    if ((typeof cons) === "function") {
+        return new cons(len);
+    }
+    else {
+        return new Array(len);
+    }
+}
+
+export { Helpers_allocateArrayFromCons };

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

@@ -0,0 +1,73 @@
+const symbol = Symbol("numeric");
+function isNumeric(x) {
+    return typeof x === "number" || typeof x === "bigint" || x?.[symbol];
+}
+function compare(x, y) {
+    if (typeof x === "number") {
+        return x < y ? -1 : (x > y ? 1 : 0);
+    }
+    else if (typeof x === "bigint") {
+        return x < y ? -1 : (x > y ? 1 : 0);
+    }
+    else {
+        return x.CompareTo(y);
+    }
+}
+function multiply(x, y) {
+    if (typeof x === "number") {
+        return x * y;
+    }
+    else if (typeof x === "bigint") {
+        return x * BigInt(y);
+    }
+    else {
+        return x[symbol]().multiply(y);
+    }
+}
+function toFixed(x, dp) {
+    if (typeof x === "number") {
+        return x.toFixed(dp);
+    }
+    else if (typeof x === "bigint") {
+        return x;
+    }
+    else {
+        return x[symbol]().toFixed(dp);
+    }
+}
+function toPrecision(x, sd) {
+    if (typeof x === "number") {
+        return x.toPrecision(sd);
+    }
+    else if (typeof x === "bigint") {
+        return x;
+    }
+    else {
+        return x[symbol]().toPrecision(sd);
+    }
+}
+function toExponential(x, dp) {
+    if (typeof x === "number") {
+        return x.toExponential(dp);
+    }
+    else if (typeof x === "bigint") {
+        return x;
+    }
+    else {
+        return x[symbol]().toExponential(dp);
+    }
+}
+function toHex(x) {
+    if (typeof x === "number") {
+        return (Number(x) >>> 0).toString(16);
+    }
+    else if (typeof x === "bigint") {
+        // TODO: properly handle other bit sizes
+        return BigInt.asUintN(64, x).toString(16);
+    }
+    else {
+        return x[symbol]().toHex();
+    }
+}
+
+export { compare, isNumeric, multiply, symbol, toExponential, toFixed, toHex, toPrecision };