@nfdi4plants/arctrl 1.0.0-alpha10

package/ISA/ISA/Helper.js

@@ -0,0 +1,338 @@
+import { some, value as value_1 } from "../../fable_modules/fable-library.4.1.4/Option.js";
+import { isIterable, defaultOf, structuralHash, equals, numberHash, identityHash } from "../../fable_modules/fable-library.4.1.4/Util.js";
+import { exactlyOne, partition, fold } from "../../fable_modules/fable-library.4.1.4/Array.js";
+import { empty, singleton, append, head, tail, isEmpty } from "../../fable_modules/fable-library.4.1.4/List.js";
+import { Dictionary } from "../../fable_modules/fable-library.4.1.4/MutableMap.js";
+import { isEmpty as isEmpty_1, iterate } from "../../fable_modules/fable-library.4.1.4/Seq.js";
+import { tryGetValue, addToDict } from "../../fable_modules/fable-library.4.1.4/MapUtil.js";
+import { Union, toString, FSharpRef } from "../../fable_modules/fable-library.4.1.4/Types.js";
+import { append_generic, distinct_generic, isList_generic, isMap_generic } from "./Fable.js";
+import { union_type, makeUnion, option_type, makeGenericType, getUnionCases, name, obj_type } from "../../fable_modules/fable-library.4.1.4/Reflection.js";
+
+export function HashCodes_boxHashOption(a) {
+    let copyOfStruct, copyOfStruct_1;
+    return (a != null) ? ((copyOfStruct = value_1(a), identityHash(copyOfStruct))) : ((copyOfStruct_1 = 0, numberHash(copyOfStruct_1)));
+}
+
+export function HashCodes_boxHashArray(a) {
+    return fold((acc, o) => {
+        let copyOfStruct;
+        return ((-1640531527 + ((copyOfStruct = o, identityHash(copyOfStruct)))) + (acc << 6)) + (acc >> 2);
+    }, 0, a);
+}
+
+/**
+ * If the value matches the default, a None is returned, else a Some is returned
+ */
+export function Option_fromValueWithDefault(d, v) {
+    if (equals(d, v)) {
+        return void 0;
+    }
+    else {
+        return some(v);
+    }
+}
+
+/**
+ * Applies the function f on the value of the option if it exists, else applies it on the default value. If the result value matches the default, a None is returned
+ */
+export function Option_mapDefault(d, f, o) {
+    return Option_fromValueWithDefault(d, (o == null) ? f(d) : f(value_1(o)));
+}
+
+/**
+ * Applies the function f on the value of the option if it exists, else returns the default value.
+ */
+export function Option_mapOrDefault(d, f, o) {
+    if (o == null) {
+        return d;
+    }
+    else {
+        return some(f(value_1(o)));
+    }
+}
+
+export function List_tryPickAndRemove(f, lst) {
+    const loop = (newList_mut, remainingList_mut) => {
+        loop:
+        while (true) {
+            const newList = newList_mut, remainingList = remainingList_mut;
+            if (!isEmpty(remainingList)) {
+                const t = tail(remainingList);
+                const h = head(remainingList);
+                const matchValue = f(h);
+                if (matchValue == null) {
+                    newList_mut = append(newList, singleton(h));
+                    remainingList_mut = t;
+                    continue loop;
+                }
+                else {
+                    return [some(value_1(matchValue)), append(newList, t)];
+                }
+            }
+            else {
+                return [void 0, newList];
+            }
+            break;
+        }
+    };
+    return loop(empty(), lst);
+}
+
+export function Dict_ofSeq(s) {
+    const dict = new Dictionary([], {
+        Equals: equals,
+        GetHashCode: structuralHash,
+    });
+    iterate((tupledArg) => {
+        addToDict(dict, tupledArg[0], tupledArg[1]);
+    }, s);
+    return dict;
+}
+
+export function Dict_tryFind(key, dict) {
+    let patternInput;
+    let outArg = defaultOf();
+    patternInput = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+    })), outArg];
+    if (patternInput[0]) {
+        return some(patternInput[1]);
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function Dict_ofSeqWithMerge(merge, s) {
+    const dict = new Dictionary([], {
+        Equals: equals,
+        GetHashCode: structuralHash,
+    });
+    iterate((tupledArg) => {
+        const k = tupledArg[0];
+        const v = tupledArg[1];
+        const matchValue = Dict_tryFind(k, dict);
+        if (matchValue == null) {
+            addToDict(dict, k, v);
+        }
+        else {
+            const v$0027 = value_1(matchValue);
+            dict.delete(k);
+            addToDict(dict, k, merge(v$0027, v));
+        }
+    }, s);
+    return dict;
+}
+
+/**
+ * Get the type of the IEnumerable elements. E.g. for Array<'T> it would be 'T
+ */
+export function Update_isMapType(v) {
+    return isMap_generic(v);
+}
+
+export function Update_isListType(v) {
+    return isList_generic(v);
+}
+
+/**
+ * Get the type of the IEnumerable elements. E.g. for Array<'T> it would be 'T
+ */
+export function Update_enumGetInnerType(v) {
+    return obj_type;
+}
+
+/**
+ * updates oldRT with newRT by replacing all values, but appending all lists.
+ * 
+ * newRTList@oldRTList
+ */
+export function Update_updateAppend(oldVal, newVal) {
+    let matchResult, oldInternal, others;
+    if (typeof oldVal === "string") {
+        matchResult = 0;
+    }
+    else if (isIterable(oldVal)) {
+        let activePatternResult;
+        const a = oldVal;
+        activePatternResult = ((a == null) ? void 0 : (undefined));
+        if (activePatternResult != null) {
+            matchResult = 1;
+            oldInternal = value_1(activePatternResult);
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        let activePatternResult_1;
+        const a_1 = oldVal;
+        activePatternResult_1 = ((a_1 == null) ? void 0 : (undefined));
+        if (activePatternResult_1 != null) {
+            matchResult = 1;
+            oldInternal = value_1(activePatternResult_1);
+        }
+        else {
+            matchResult = 3;
+            others = oldVal;
+        }
+    }
+    switch (matchResult) {
+        case 0:
+            return newVal;
+        case 1:
+            if (typeof oldInternal === "string") {
+                return newVal;
+            }
+            else if (isIterable(oldInternal)) {
+                let activePatternResult_2;
+                const a_2 = newVal;
+                activePatternResult_2 = ((a_2 == null) ? void 0 : (undefined));
+                if (activePatternResult_2 != null) {
+                    const newInternal = value_1(activePatternResult_2);
+                    const v = Update_updateAppend(oldInternal, newInternal);
+                    const cases_1 = partition((x) => (name(x) === "Some"), getUnionCases(makeGenericType(option_type(obj_type), [obj_type])));
+                    const patternInput = [exactlyOne(cases_1[0]), [v]];
+                    return makeUnion(patternInput[0], patternInput[1]);
+                }
+                else {
+                    return oldVal;
+                }
+            }
+            else {
+                return newVal;
+            }
+        case 2: {
+            const oldSeq = oldVal;
+            const newSeq = newVal;
+            const innerType = Update_enumGetInnerType(oldVal);
+            if (Update_isMapType(oldVal)) {
+                return newVal;
+            }
+            else {
+                return distinct_generic(append_generic(oldSeq, newSeq));
+            }
+        }
+        default:
+            return newVal;
+    }
+}
+
+/**
+ * updates oldRT with newRT by replacing all values, but only if the new value is not empty.
+ */
+export function Update_updateOnlyByExisting(oldVal, newVal) {
+    if (equals(newVal, defaultOf())) {
+        return oldVal;
+    }
+    else {
+        let activePatternResult;
+        const a = oldVal;
+        activePatternResult = ((a == null) ? void 0 : (undefined));
+        if (activePatternResult != null) {
+            const oldInternal = value_1(activePatternResult);
+            let activePatternResult_1;
+            const a_1 = newVal;
+            activePatternResult_1 = ((a_1 == null) ? void 0 : (undefined));
+            if (activePatternResult_1 != null) {
+                const newInternal = value_1(activePatternResult_1);
+                const v = Update_updateOnlyByExisting(oldInternal, newInternal);
+                const cases_1 = partition((x) => (name(x) === "Some"), getUnionCases(makeGenericType(option_type(obj_type), [obj_type])));
+                const patternInput = [exactlyOne(cases_1[0]), [v]];
+                return makeUnion(patternInput[0], patternInput[1]);
+            }
+            else {
+                return oldVal;
+            }
+        }
+        else if (typeof oldVal === "string") {
+            const newStr = newVal;
+            if (toString(newStr) === "") {
+                return oldVal;
+            }
+            else {
+                return newStr;
+            }
+        }
+        else if (isIterable(oldVal)) {
+            const newSeq = newVal;
+            if (isEmpty_1(newSeq)) {
+                return oldVal;
+            }
+            else {
+                return newSeq;
+            }
+        }
+        else {
+            return newVal;
+        }
+    }
+}
+
+/**
+ * updates oldRT with newRT by replacing all values, but only if the new value is not empty.
+ */
+export function Update_updateOnlyByExistingAppend(oldVal, newVal) {
+    if (equals(newVal, defaultOf())) {
+        return oldVal;
+    }
+    else {
+        let activePatternResult;
+        const a = oldVal;
+        activePatternResult = ((a == null) ? void 0 : (undefined));
+        if (activePatternResult != null) {
+            const oldInternal = value_1(activePatternResult);
+            let activePatternResult_1;
+            const a_1 = newVal;
+            activePatternResult_1 = ((a_1 == null) ? void 0 : (undefined));
+            if (activePatternResult_1 != null) {
+                const newInternal = value_1(activePatternResult_1);
+                const v = Update_updateOnlyByExistingAppend(oldInternal, newInternal);
+                const cases_1 = partition((x) => (name(x) === "Some"), getUnionCases(makeGenericType(option_type(obj_type), [obj_type])));
+                const patternInput = [exactlyOne(cases_1[0]), [v]];
+                return makeUnion(patternInput[0], patternInput[1]);
+            }
+            else {
+                return oldVal;
+            }
+        }
+        else if (typeof oldVal === "string") {
+            const newStr = newVal;
+            if (toString(newStr) === "") {
+                return oldVal;
+            }
+            else {
+                return newStr;
+            }
+        }
+        else if (isIterable(oldVal)) {
+            const innerType = Update_enumGetInnerType(oldVal);
+            if (Update_isMapType(oldVal)) {
+                return newVal;
+            }
+            else {
+                return distinct_generic(append_generic(oldVal, newVal));
+            }
+        }
+        else {
+            return newVal;
+        }
+    }
+}
+
+export class Update_UpdateOptions extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["UpdateAll", "UpdateByExisting", "UpdateAllAppendLists", "UpdateByExistingAppendLists"];
+    }
+}
+
+export function Update_UpdateOptions_$reflection() {
+    return union_type("ARCtrl.ISA.Aux.Update.UpdateOptions", [], Update_UpdateOptions, () => [[], [], [], []]);
+}
+

package/ISA/ISA/Identifier.js

@@ -0,0 +1,76 @@
+import { match, isMatch } from "../../fable_modules/fable-library.4.1.4/RegExp.js";
+import { newGuid } from "../../fable_modules/fable-library.4.1.4/Guid.js";
+import { combineMany } from "../../FileSystem/Path.js";
+
+export function checkValidCharacters(identifier) {
+    if (!isMatch(/^[a-zA-Z0-9_\- ]+$/gu, identifier)) {
+        throw new Error("New identifier contains forbidden characters! Allowed characters are: letters, digits, underscore (_), dash (-) and whitespace ( ).");
+    }
+}
+
+export function createMissingIdentifier() {
+    let copyOfStruct;
+    return "MISSING_IDENTIFIER_" + ((copyOfStruct = newGuid(), copyOfStruct));
+}
+
+export function isMissingIdentifier(str) {
+    return str.indexOf("MISSING_IDENTIFIER_") === 0;
+}
+
+export function removeMissingIdentifier(str) {
+    if (str.indexOf("MISSING_IDENTIFIER_") === 0) {
+        return "";
+    }
+    else {
+        return str;
+    }
+}
+
+/**
+ * On read-in the FileName can be any combination of "assays" (assay folder name), assayIdentifier and "isa.assay.xlsx" (the actual file name).
+ * 
+ * This functions extracts assayIdentifier from any of these combinations and returns it.
+ */
+export function Assay_identifierFromFileName(fileName) {
+    const m = match(/^(assays(\/|\\))?(?<identifier>[a-zA-Z0-9_\- ]+)((\/|\\)isa.assay.xlsx)?$/gu, fileName);
+    const matchValue = m != null;
+    if (matchValue) {
+        return (m.groups && m.groups.identifier) || "";
+    }
+    else {
+        throw new Error(`Cannot parse identifier from FileName \`${fileName}\``);
+    }
+}
+
+/**
+ * On writing a xlsx file we unify our output to a relative path to ARC root. So: `assays/assayIdentifier/isa.assay.xlsx`.
+ */
+export function Assay_fileNameFromIdentifier(identifier) {
+    checkValidCharacters(identifier);
+    return combineMany(["assays", identifier, "isa.assay.xlsx"]);
+}
+
+/**
+ * On read-in the FileName can be any combination of "studies" (study folder name), studyIdentifier and "isa.study.xlsx" (the actual file name).
+ * 
+ * This functions extracts studyIdentifier from any of these combinations and returns it.
+ */
+export function Study_identifierFromFileName(fileName) {
+    const m = match(/^(studies(\/|\\))?(?<identifier>[a-zA-Z0-9_\- ]+)((\/|\\)isa.study.xlsx)?$/gu, fileName);
+    const matchValue = m != null;
+    if (matchValue) {
+        return (m.groups && m.groups.identifier) || "";
+    }
+    else {
+        throw new Error(`Cannot parse identifier from FileName \`${fileName}\``);
+    }
+}
+
+/**
+ * On writing a xlsx file we unify our output to a relative path to ARC root. So: `studies/studyIdentifier/isa.study.xlsx`.
+ */
+export function Study_fileNameFromIdentifier(identifier) {
+    checkValidCharacters(identifier);
+    return combineMany(["studies", identifier, "isa.study.xlsx"]);
+}
+

package/ISA/ISA/JsonTypes/AnnotationValue.js

@@ -0,0 +1,56 @@
+import { Union } from "../../../fable_modules/fable-library.4.1.4/Types.js";
+import { union_type, int32_type, float64_type, string_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { parse } from "../../../fable_modules/fable-library.4.1.4/Double.js";
+import { parse as parse_1 } from "../../../fable_modules/fable-library.4.1.4/Int32.js";
+import { int32ToString } from "../../../fable_modules/fable-library.4.1.4/Util.js";
+
+export class AnnotationValue extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Text", "Float", "Int"];
+    }
+}
+
+export function AnnotationValue_$reflection() {
+    return union_type("ARCtrl.ISA.AnnotationValue", [], AnnotationValue, () => [[["Item", string_type]], [["Item", float64_type]], [["Item", int32_type]]]);
+}
+
+export function AnnotationValue_get_empty() {
+    return new AnnotationValue(0, [""]);
+}
+
+/**
+ * Create a ISAJson Annotation value from a ISATab string entry
+ */
+export function AnnotationValue_fromString_Z721C83C5(s) {
+    try {
+        return new AnnotationValue(2, [parse_1(s, 511, false, 32)]);
+    }
+    catch (matchValue) {
+        try {
+            return new AnnotationValue(1, [parse(s)]);
+        }
+        catch (matchValue_1) {
+            return new AnnotationValue(0, [s]);
+        }
+    }
+}
+
+/**
+ * Get a ISATab string Annotation Name from a ISAJson object
+ */
+export function AnnotationValue_toString_Z6FAD7738(v) {
+    switch (v.tag) {
+        case 2:
+            return int32ToString(v.fields[0]);
+        case 1:
+            return v.fields[0].toString();
+        default:
+            return v.fields[0];
+    }
+}
+