@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/esm/ts/Spreadsheet/AnnotationTable/CompositeHeader.js

@@ -0,0 +1,460 @@
+import { printf, toFail } from "@fable-org/fable-library-js/String.js";
+import { map, value } from "@fable-org/fable-library-js/Option.js";
+import { OntologyAnnotation } from "../../Core/OntologyAnnotation.js";
+import { freeTextFromStringCells, dataFromStringCells, unitizedFromStringCells, termFromStringCells } from "./CompositeCell.js";
+import { CompositeHeader_FreeText, CompositeHeader_Date, CompositeHeader_Performer, CompositeHeader_ProtocolVersion, CompositeHeader_ProtocolUri, CompositeHeader_ProtocolDescription, CompositeHeader_ProtocolREF, CompositeHeader_ProtocolType, CompositeHeader_Comment, CompositeHeader_Output, CompositeHeader_Input, IOType_Data, IOType, CompositeHeader_Component, CompositeHeader_Characteristic, CompositeHeader_Factor, CompositeHeader_Parameter } from "../../Core/Table/CompositeHeader.js";
+import { tryFindIndex, skip, item, equalsWith } from "@fable-org/fable-library-js/Array.js";
+import { defaultOf } from "@fable-org/fable-library-js/Util.js";
+import { ActivePatterns_$007CComment$007C_$007C, ActivePatterns_$007COutputColumnHeader$007C_$007C, ActivePatterns_$007CInputColumnHeader$007C_$007C, tryParseComponentColumnHeader, tryParseCharacteristicColumnHeader, tryParseFactorColumnHeader, tryParseParameterColumnHeader, ActivePatterns_$007CTSRColumnHeader$007C_$007C, ActivePatterns_$007CTANColumnHeader$007C_$007C, ActivePatterns_$007CUnitColumnHeader$007C_$007C } from "../../Core/Helper/Regex.js";
+import { toString } from "@fable-org/fable-library-js/Types.js";
+import { empty, singleton, append, delay, toArray } from "@fable-org/fable-library-js/Seq.js";
+export function ActivePattern_mergeIDInfo(idSpace1, localID1, idSpace2, localID2) {
+    if (idSpace1 !== idSpace2) {
+        toFail(printf("TermSourceRef %s and %s do not match"))(idSpace1)(idSpace2);
+    }
+    if (localID1 !== localID2) {
+        toFail(printf("LocalID %s and %s do not match"))(localID1)(localID2);
+    }
+    return {
+        TermAccessionNumber: `${idSpace1}:${localID1}`,
+        TermSourceRef: idSpace1,
+    };
+}
+export function ActivePattern_$007CTerm$007C_$007C(categoryParser, f, cellValues) {
+    const $007CAC$007C_$007C = categoryParser;
+    let matchResult, name, name_1, term1, term2;
+    if (!equalsWith((x, y) => (x === y), cellValues, defaultOf()) && (cellValues.length === 1)) {
+        const activePatternResult = $007CAC$007C_$007C(item(0, cellValues));
+        if (activePatternResult != null) {
+            matchResult = 0;
+            name = value(activePatternResult);
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else if (!equalsWith((x_1, y_1) => (x_1 === y_1), cellValues, defaultOf()) && (cellValues.length === 3)) {
+        const activePatternResult_1 = $007CAC$007C_$007C(item(0, cellValues));
+        if (activePatternResult_1 != null) {
+            const activePatternResult_2 = ActivePatterns_$007CTSRColumnHeader$007C_$007C(item(1, cellValues));
+            if (activePatternResult_2 != null) {
+                const activePatternResult_3 = ActivePatterns_$007CTANColumnHeader$007C_$007C(item(2, cellValues));
+                if (activePatternResult_3 != null) {
+                    matchResult = 1;
+                    name_1 = value(activePatternResult_1);
+                    term1 = value(activePatternResult_2);
+                    term2 = value(activePatternResult_3);
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else {
+                matchResult = 2;
+            }
+        }
+        else {
+            matchResult = 2;
+        }
+    }
+    else {
+        matchResult = 2;
+    }
+    switch (matchResult) {
+        case 0:
+            return [f(OntologyAnnotation.create(name)), (cellValues_1) => termFromStringCells(undefined, undefined, cellValues_1)];
+        case 1: {
+            const term = ActivePattern_mergeIDInfo(term1.IDSpace, term1.LocalID, term2.IDSpace, term2.LocalID);
+            return [f(OntologyAnnotation.create(name_1, term.TermSourceRef, term.TermAccessionNumber)), (cellValues_2) => termFromStringCells(1, 2, cellValues_2)];
+        }
+        default: {
+            let matchResult_1, name_2, term1_1, term2_1;
+            if (!equalsWith((x_2, y_2) => (x_2 === y_2), cellValues, defaultOf()) && (cellValues.length === 3)) {
+                const activePatternResult_4 = $007CAC$007C_$007C(item(0, cellValues));
+                if (activePatternResult_4 != null) {
+                    const activePatternResult_5 = ActivePatterns_$007CTANColumnHeader$007C_$007C(item(1, cellValues));
+                    if (activePatternResult_5 != null) {
+                        const activePatternResult_6 = ActivePatterns_$007CTSRColumnHeader$007C_$007C(item(2, cellValues));
+                        if (activePatternResult_6 != null) {
+                            matchResult_1 = 0;
+                            name_2 = value(activePatternResult_4);
+                            term1_1 = value(activePatternResult_6);
+                            term2_1 = value(activePatternResult_5);
+                        }
+                        else {
+                            matchResult_1 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+            }
+            else {
+                matchResult_1 = 1;
+            }
+            switch (matchResult_1) {
+                case 0: {
+                    const term_1 = ActivePattern_mergeIDInfo(term1_1.IDSpace, term1_1.LocalID, term2_1.IDSpace, term2_1.LocalID);
+                    return [f(OntologyAnnotation.create(name_2, term_1.TermSourceRef, term_1.TermAccessionNumber)), (cellValues_3) => termFromStringCells(2, 1, cellValues_3)];
+                }
+                default: {
+                    let matchResult_2, name_3, term1_2, term2_2;
+                    if (!equalsWith((x_3, y_3) => (x_3 === y_3), cellValues, defaultOf()) && (cellValues.length === 4)) {
+                        const activePatternResult_7 = $007CAC$007C_$007C(item(0, cellValues));
+                        if (activePatternResult_7 != null) {
+                            if (ActivePatterns_$007CUnitColumnHeader$007C_$007C(item(1, cellValues)) != null) {
+                                const activePatternResult_9 = ActivePatterns_$007CTSRColumnHeader$007C_$007C(item(2, cellValues));
+                                if (activePatternResult_9 != null) {
+                                    const activePatternResult_10 = ActivePatterns_$007CTANColumnHeader$007C_$007C(item(3, cellValues));
+                                    if (activePatternResult_10 != null) {
+                                        matchResult_2 = 0;
+                                        name_3 = value(activePatternResult_7);
+                                        term1_2 = value(activePatternResult_9);
+                                        term2_2 = value(activePatternResult_10);
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                }
+                                else {
+                                    matchResult_2 = 1;
+                                }
+                            }
+                            else {
+                                matchResult_2 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_2 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_2 = 1;
+                    }
+                    switch (matchResult_2) {
+                        case 0: {
+                            const term_2 = ActivePattern_mergeIDInfo(term1_2.IDSpace, term1_2.LocalID, term2_2.IDSpace, term2_2.LocalID);
+                            return [f(OntologyAnnotation.create(name_3, term_2.TermSourceRef, term_2.TermAccessionNumber)), (cellValues_4) => unitizedFromStringCells(1, 2, 3, cellValues_4)];
+                        }
+                        default: {
+                            let matchResult_3, name_4, term1_3, term2_3;
+                            if (!equalsWith((x_4, y_4) => (x_4 === y_4), cellValues, defaultOf()) && (cellValues.length === 4)) {
+                                const activePatternResult_11 = $007CAC$007C_$007C(item(0, cellValues));
+                                if (activePatternResult_11 != null) {
+                                    if (ActivePatterns_$007CUnitColumnHeader$007C_$007C(item(1, cellValues)) != null) {
+                                        const activePatternResult_13 = ActivePatterns_$007CTANColumnHeader$007C_$007C(item(2, cellValues));
+                                        if (activePatternResult_13 != null) {
+                                            const activePatternResult_14 = ActivePatterns_$007CTSRColumnHeader$007C_$007C(item(3, cellValues));
+                                            if (activePatternResult_14 != null) {
+                                                matchResult_3 = 0;
+                                                name_4 = value(activePatternResult_11);
+                                                term1_3 = value(activePatternResult_14);
+                                                term2_3 = value(activePatternResult_13);
+                                            }
+                                            else {
+                                                matchResult_3 = 1;
+                                            }
+                                        }
+                                        else {
+                                            matchResult_3 = 1;
+                                        }
+                                    }
+                                    else {
+                                        matchResult_3 = 1;
+                                    }
+                                }
+                                else {
+                                    matchResult_3 = 1;
+                                }
+                            }
+                            else {
+                                matchResult_3 = 1;
+                            }
+                            switch (matchResult_3) {
+                                case 0: {
+                                    const term_3 = ActivePattern_mergeIDInfo(term1_3.IDSpace, term1_3.LocalID, term2_3.IDSpace, term2_3.LocalID);
+                                    return [f(OntologyAnnotation.create(name_4, term_3.TermSourceRef, term_3.TermAccessionNumber)), (cellValues_5) => unitizedFromStringCells(1, 3, 2, cellValues_5)];
+                                }
+                                default:
+                                    return undefined;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+export function ActivePattern_$007CParameter$007C_$007C(cellValues) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C(tryParseParameterColumnHeader, CompositeHeader_Parameter, cellValues);
+    if (activePatternResult != null) {
+        const r = value(activePatternResult);
+        return r;
+    }
+    else {
+        return undefined;
+    }
+}
+export function ActivePattern_$007CFactor$007C_$007C(cellValues) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C(tryParseFactorColumnHeader, CompositeHeader_Factor, cellValues);
+    if (activePatternResult != null) {
+        const r = value(activePatternResult);
+        return r;
+    }
+    else {
+        return undefined;
+    }
+}
+export function ActivePattern_$007CCharacteristic$007C_$007C(cellValues) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C(tryParseCharacteristicColumnHeader, CompositeHeader_Characteristic, cellValues);
+    if (activePatternResult != null) {
+        const r = value(activePatternResult);
+        return r;
+    }
+    else {
+        return undefined;
+    }
+}
+export function ActivePattern_$007CComponent$007C_$007C(cellValues) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C(tryParseComponentColumnHeader, CompositeHeader_Component, cellValues);
+    if (activePatternResult != null) {
+        const r = value(activePatternResult);
+        return r;
+    }
+    else {
+        return undefined;
+    }
+}
+export function ActivePattern_$007CInput$007C_$007C(cellValues) {
+    if (cellValues.length === 0) {
+        return undefined;
+    }
+    else {
+        const matchValue = item(0, cellValues);
+        const activePatternResult = ActivePatterns_$007CInputColumnHeader$007C_$007C(matchValue);
+        if (activePatternResult != null) {
+            const ioType = value(activePatternResult);
+            const cols = skip(1, cellValues);
+            const matchValue_1 = IOType.ofString(ioType);
+            if (matchValue_1.tag === /* Data */ 2) {
+                const format = map((y) => (1 + y), tryFindIndex((s) => s.startsWith("Data Format"), cols));
+                const selectorFormat = map((y_1) => (1 + y_1), tryFindIndex((s_1) => s_1.startsWith("Data Selector Format"), cols));
+                return [CompositeHeader_Input(IOType_Data()), (cellValues_1) => dataFromStringCells(format, selectorFormat, cellValues_1)];
+            }
+            else {
+                return [CompositeHeader_Input(matchValue_1), freeTextFromStringCells];
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+export function ActivePattern_$007COutput$007C_$007C(cellValues) {
+    if (cellValues.length === 0) {
+        return undefined;
+    }
+    else {
+        const matchValue = item(0, cellValues);
+        const activePatternResult = ActivePatterns_$007COutputColumnHeader$007C_$007C(matchValue);
+        if (activePatternResult != null) {
+            const ioType = value(activePatternResult);
+            const cols = skip(1, cellValues);
+            const matchValue_1 = IOType.ofString(ioType);
+            if (matchValue_1.tag === /* Data */ 2) {
+                const format = map((y) => (1 + y), tryFindIndex((s) => s.startsWith("Data Format"), cols));
+                const selectorFormat = map((y_1) => (1 + y_1), tryFindIndex((s_1) => s_1.startsWith("Data Selector Format"), cols));
+                return [CompositeHeader_Output(IOType_Data()), (cellValues_1) => dataFromStringCells(format, selectorFormat, cellValues_1)];
+            }
+            else {
+                return [CompositeHeader_Output(matchValue_1), freeTextFromStringCells];
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+export function ActivePattern_$007CComment$007C_$007C(cellValues) {
+    let matchResult, key;
+    if (!equalsWith((x, y) => (x === y), cellValues, defaultOf()) && (cellValues.length === 1)) {
+        const activePatternResult = ActivePatterns_$007CComment$007C_$007C(item(0, cellValues));
+        if (activePatternResult != null) {
+            matchResult = 0;
+            key = value(activePatternResult);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return [CompositeHeader_Comment(key), freeTextFromStringCells];
+        default:
+            return undefined;
+    }
+}
+export function ActivePattern_$007CProtocolType$007C_$007C(cellValues) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C((s) => {
+        if (s === "Protocol Type") {
+            return s;
+        }
+        else {
+            return undefined;
+        }
+    }, (_arg) => CompositeHeader_ProtocolType(), cellValues);
+    if (activePatternResult != null) {
+        const r = value(activePatternResult);
+        return r;
+    }
+    else {
+        return undefined;
+    }
+}
+export function ActivePattern_$007CProtocolHeader$007C_$007C(cellValues) {
+    let matchResult;
+    if (!equalsWith((x, y) => (x === y), cellValues, defaultOf()) && (cellValues.length === 1)) {
+        if (item(0, cellValues) === "Protocol REF") {
+            matchResult = 0;
+        }
+        else if (item(0, cellValues) === "Protocol Description") {
+            matchResult = 1;
+        }
+        else if (item(0, cellValues) === "Protocol Uri") {
+            matchResult = 2;
+        }
+        else if (item(0, cellValues) === "Protocol Version") {
+            matchResult = 3;
+        }
+        else if (item(0, cellValues) === "Performer") {
+            matchResult = 4;
+        }
+        else if (item(0, cellValues) === "Date") {
+            matchResult = 5;
+        }
+        else {
+            matchResult = 6;
+        }
+    }
+    else {
+        matchResult = 6;
+    }
+    switch (matchResult) {
+        case 0:
+            return [CompositeHeader_ProtocolREF(), freeTextFromStringCells];
+        case 1:
+            return [CompositeHeader_ProtocolDescription(), freeTextFromStringCells];
+        case 2:
+            return [CompositeHeader_ProtocolUri(), freeTextFromStringCells];
+        case 3:
+            return [CompositeHeader_ProtocolVersion(), freeTextFromStringCells];
+        case 4:
+            return [CompositeHeader_Performer(), freeTextFromStringCells];
+        case 5:
+            return [CompositeHeader_Date(), freeTextFromStringCells];
+        default:
+            return undefined;
+    }
+}
+export function ActivePattern_$007CFreeText$007C_$007C(cellValues) {
+    if (!equalsWith((x, y) => (x === y), cellValues, defaultOf()) && (cellValues.length === 1)) {
+        return [CompositeHeader_FreeText(item(0, cellValues)), freeTextFromStringCells];
+    }
+    else {
+        return undefined;
+    }
+}
+export function fromStringCells(cellValues) {
+    const activePatternResult = ActivePattern_$007CParameter$007C_$007C(cellValues);
+    if (activePatternResult != null) {
+        const p = value(activePatternResult);
+        return p;
+    }
+    else {
+        const activePatternResult_1 = ActivePattern_$007CFactor$007C_$007C(cellValues);
+        if (activePatternResult_1 != null) {
+            const f = value(activePatternResult_1);
+            return f;
+        }
+        else {
+            const activePatternResult_2 = ActivePattern_$007CCharacteristic$007C_$007C(cellValues);
+            if (activePatternResult_2 != null) {
+                const c = value(activePatternResult_2);
+                return c;
+            }
+            else {
+                const activePatternResult_3 = ActivePattern_$007CComponent$007C_$007C(cellValues);
+                if (activePatternResult_3 != null) {
+                    const c_1 = value(activePatternResult_3);
+                    return c_1;
+                }
+                else {
+                    const activePatternResult_4 = ActivePattern_$007CInput$007C_$007C(cellValues);
+                    if (activePatternResult_4 != null) {
+                        const i = value(activePatternResult_4);
+                        return i;
+                    }
+                    else {
+                        const activePatternResult_5 = ActivePattern_$007COutput$007C_$007C(cellValues);
+                        if (activePatternResult_5 != null) {
+                            const o = value(activePatternResult_5);
+                            return o;
+                        }
+                        else {
+                            const activePatternResult_6 = ActivePattern_$007CProtocolType$007C_$007C(cellValues);
+                            if (activePatternResult_6 != null) {
+                                const pt = value(activePatternResult_6);
+                                return pt;
+                            }
+                            else {
+                                const activePatternResult_7 = ActivePattern_$007CProtocolHeader$007C_$007C(cellValues);
+                                if (activePatternResult_7 != null) {
+                                    const ph = value(activePatternResult_7);
+                                    return ph;
+                                }
+                                else {
+                                    const activePatternResult_8 = ActivePattern_$007CComment$007C_$007C(cellValues);
+                                    if (activePatternResult_8 != null) {
+                                        const c_2 = value(activePatternResult_8);
+                                        return c_2;
+                                    }
+                                    else {
+                                        const activePatternResult_9 = ActivePattern_$007CFreeText$007C_$007C(cellValues);
+                                        if (activePatternResult_9 != null) {
+                                            const ft = value(activePatternResult_9);
+                                            return ft;
+                                        }
+                                        else {
+                                            return toFail(printf("Could not parse header group %O"))(cellValues);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+export function toStringCells(hasUnit, header) {
+    if (header.IsDataColumn) {
+        return [toString(header), "Data Format", "Data Selector Format"];
+    }
+    else if (header.IsSingleColumn) {
+        return [toString(header)];
+    }
+    else if (header.IsTermColumn) {
+        return toArray(delay(() => append(singleton(toString(header)), delay(() => append(hasUnit ? singleton("Unit") : empty(), delay(() => append(singleton(`Term Source REF (${header.GetColumnAccessionShort})`), delay(() => singleton(`Term Accession Number (${header.GetColumnAccessionShort})`)))))))));
+    }
+    else {
+        return toFail(printf("header %O is neither single nor term column"))(header);
+    }
+}

package/dist/ts/esm/ts/Spreadsheet/ArcAssay.js

@@ -0,0 +1,204 @@
+import { iterate, isEmpty as isEmpty_1, tryPick, choose, tryFind, map, iterateIndexed, singleton, append, delay, tryHead, head, exists } from "@fable-org/fable-library-js/Seq.js";
+import { unwrap, toArray, value as value_1, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { getEnumerator } from "@fable-org/fable-library-js/Util.js";
+import { toRows, fromRows } from "./Metadata/Assays.js";
+import { ofSeq, singleton as singleton_1, empty, isEmpty } from "@fable-org/fable-library-js/List.js";
+import { ArcAssay } from "../Core/ArcTypes.js";
+import { toRows as toRows_1, fromRows as fromRows_1 } from "./Metadata/Contacts.js";
+import { createMissingIdentifier } from "../Core/Helper/Identifier.js";
+import { SparseRowModule_fromAllValues, SparseRowModule_getAllValues, SparseRowModule_fromFsRow, SparseRowModule_writeToSheet, SparseRowModule_fromValues, SparseRowModule_tryGetValueAt } from "./Metadata/SparseTable.js";
+import { FsWorksheet } from "../fable_modules/FsSpreadsheet.6.3.1/FsWorksheet.fs.js";
+import { toConsole, printf, toFail } from "@fable-org/fable-library-js/String.js";
+import { FsWorkbook } from "../fable_modules/FsSpreadsheet.6.3.1/FsWorkbook.fs.js";
+import { toFsWorksheet as toFsWorksheet_1, tryFromFsWorksheet } from "./AnnotationTable/ArcTable.js";
+import { toFsWorksheet, tryFromFsWorksheet as tryFromFsWorksheet_1 } from "./DataMapTable/DataMapTable.js";
+export function ArcAssay_fromRows(rows) {
+    const patternInput = exists((row) => {
+        const s = head(row)[1];
+        return s.startsWith("Assay");
+    }, rows) ? ["Assay", "Assay Person"] : [undefined, undefined];
+    const en = getEnumerator(rows);
+    const loop = (lastRow_mut, assays_mut, contacts_mut, rowNumber_mut) => {
+        let prefix;
+        loop: while (true) {
+            const lastRow = lastRow_mut, assays = assays_mut, contacts = contacts_mut, rowNumber = rowNumber_mut;
+            let matchResult, prefix_2, prefix_3;
+            if (lastRow != null) {
+                if ((prefix = value_1(lastRow), (prefix === "ASSAY") ? true : (prefix === "ASSAY METADATA"))) {
+                    matchResult = 0;
+                    prefix_2 = value_1(lastRow);
+                }
+                else if (value_1(lastRow) === "ASSAY PERFORMERS") {
+                    matchResult = 1;
+                    prefix_3 = value_1(lastRow);
+                }
+                else {
+                    matchResult = 2;
+                }
+            }
+            else {
+                matchResult = 2;
+            }
+            switch (matchResult) {
+                case 0: {
+                    const patternInput_1 = fromRows(patternInput[0], rowNumber + 1, en);
+                    lastRow_mut = patternInput_1[0];
+                    assays_mut = patternInput_1[3];
+                    contacts_mut = contacts;
+                    rowNumber_mut = patternInput_1[1];
+                    continue loop;
+                }
+                case 1: {
+                    const patternInput_2 = fromRows_1(patternInput[1], rowNumber + 1, en);
+                    lastRow_mut = patternInput_2[0];
+                    assays_mut = assays;
+                    contacts_mut = patternInput_2[3];
+                    rowNumber_mut = patternInput_2[1];
+                    continue loop;
+                }
+                default: {
+                    let matchResult_1, assays_2, contacts_2;
+                    if (isEmpty(assays)) {
+                        if (isEmpty(contacts)) {
+                            matchResult_1 = 0;
+                        }
+                        else {
+                            matchResult_1 = 1;
+                            assays_2 = assays;
+                            contacts_2 = contacts;
+                        }
+                    }
+                    else {
+                        matchResult_1 = 1;
+                        assays_2 = assays;
+                        contacts_2 = contacts;
+                    }
+                    switch (matchResult_1) {
+                        case 0:
+                            return ArcAssay.create(createMissingIdentifier());
+                        default: {
+                            const performers = Array.from(contacts_2);
+                            const assay = defaultArg(tryHead(assays_2), ArcAssay.create(createMissingIdentifier()));
+                            return ArcAssay.setPerformers(performers, assay);
+                        }
+                    }
+                }
+            }
+            break;
+        }
+    };
+    if (en["System.Collections.IEnumerator.MoveNext"]()) {
+        return loop(SparseRowModule_tryGetValueAt(0, en["System.Collections.Generic.IEnumerator`1.get_Current"]()), empty(), empty(), 1);
+    }
+    else {
+        throw new Error("empty assay metadata sheet");
+    }
+}
+export function ArcAssay_toRows(assay) {
+    return delay(() => append(singleton(SparseRowModule_fromValues(["ASSAY"])), delay(() => append(toRows("Assay", singleton_1(assay)), delay(() => append(singleton(SparseRowModule_fromValues(["ASSAY PERFORMERS"])), delay(() => toRows_1("Assay Person", ofSeq(assay.Performers)))))))));
+}
+export function ArcAssay_toMetadataSheet(assay) {
+    const sheet = new FsWorksheet("isa_assay");
+    iterateIndexed((rowI, r) => {
+        SparseRowModule_writeToSheet(rowI + 1, r, sheet);
+    }, ArcAssay_toRows(assay));
+    return sheet;
+}
+export function ArcAssay_fromMetadataSheet(sheet) {
+    try {
+        const rows = map(SparseRowModule_fromFsRow, sheet.Rows);
+        const hasPrefix = exists((row) => {
+            const s = head(row)[1];
+            return s.startsWith("Assay");
+        }, rows);
+        return ArcAssay_fromRows(rows);
+    }
+    catch (err) {
+        const arg = err.message;
+        return toFail(printf("Failed while parsing metadatasheet: %s"))(arg);
+    }
+}
+export function ArcAssay_toMetadataCollection(assay) {
+    return map(SparseRowModule_getAllValues, ArcAssay_toRows(assay));
+}
+export function ArcAssay_fromMetadataCollection(collection) {
+    try {
+        return ArcAssay_fromRows(map(SparseRowModule_fromAllValues, collection));
+    }
+    catch (err) {
+        const arg = err.message;
+        return toFail(printf("Failed while parsing metadatasheet: %s"))(arg);
+    }
+}
+export function ArcAssay_isMetadataSheetName(name) {
+    if (name === "isa_assay") {
+        return true;
+    }
+    else {
+        return name === "Assay";
+    }
+}
+export function ArcAssay_isMetadataSheet(sheet) {
+    return ArcAssay_isMetadataSheetName(sheet.Name);
+}
+export function ArcAssay_tryGetMetadataSheet(doc) {
+    return tryFind(ArcAssay_isMetadataSheet, doc.GetWorksheets());
+}
+/**
+ * Reads an assay from a spreadsheet
+ */
+export function ARCtrl_ArcAssay__ArcAssay_fromFsWorkbook_Static_32154C9D(doc) {
+    try {
+        let assayMetadata;
+        const matchValue = ArcAssay_tryGetMetadataSheet(doc);
+        if (matchValue == null) {
+            toConsole(printf("Cannot retrieve metadata: Assay file does not contain \"%s\" or \"%s\" sheet."))("isa_assay")("Assay");
+            assayMetadata = ArcAssay.create(createMissingIdentifier());
+        }
+        else {
+            assayMetadata = ArcAssay_fromMetadataSheet(value_1(matchValue));
+        }
+        const sheets = doc.GetWorksheets();
+        const annotationTables = choose(tryFromFsWorksheet, sheets);
+        const datamapSheet = tryPick(tryFromFsWorksheet_1, sheets);
+        if (!isEmpty_1(annotationTables)) {
+            assayMetadata.Tables = Array.from(annotationTables);
+        }
+        assayMetadata.DataMap = datamapSheet;
+        return assayMetadata;
+    }
+    catch (err) {
+        const arg_2 = err.message;
+        return toFail(printf("Could not parse assay: \n%s"))(arg_2);
+    }
+}
+/**
+ * Write an assay to a spreadsheet
+ *
+ * If datamapSheet is true, the datamap will be written to a worksheet inside assay workbook.
+ */
+export function ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F(assay, datamapSheet) {
+    const datamapSheet_1 = defaultArg(datamapSheet, true);
+    const doc = new FsWorkbook();
+    const metadataSheet = ArcAssay_toMetadataSheet(assay);
+    doc.AddWorksheet(metadataSheet);
+    if (datamapSheet_1) {
+        iterate((arg) => {
+            const sheet = toFsWorksheet(arg);
+            doc.AddWorksheet(sheet);
+        }, toArray(assay.DataMap));
+    }
+    iterateIndexed((i, arg_1) => {
+        const sheet_1 = toFsWorksheet_1(i, arg_1);
+        doc.AddWorksheet(sheet_1);
+    }, assay.Tables);
+    return doc;
+}
+/**
+ * Write an assay to a spreadsheet
+ *
+ * If datamapSheet is true, the datamap will be written to a worksheet inside assay workbook.
+ */
+export function ARCtrl_ArcAssay__ArcAssay_ToFsWorkbook_6FCE9E49(this$, datamapSheet) {
+    return ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F(this$, unwrap(datamapSheet));
+}