@nfdi4plants/arctrl 1.0.0-alpha10

package/ISA/ISA.Spreadsheet/AnnotationTable/CompositeColumn.js

@@ -0,0 +1,59 @@
+import { CompositeHeader, IOType } from "../../ISA/ArcTypes/CompositeHeader.js";
+import { toString } from "../../../fable_modules/fable-library.4.1.4/Types.js";
+import { toFsCells, fromFsCells } from "./CompositeHeader.js";
+import { singleton as singleton_1, ofArray, item, map } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { FsAddress__get_RowNumber } from "../../../fable_modules/FsSpreadsheet.4.1.0/FsAddress.fs.js";
+import { FsRangeAddress__get_LastAddress } from "../../../fable_modules/FsSpreadsheet.4.1.0/Ranges/FsRangeAddress.fs.js";
+import { FsRangeBase__get_RangeAddress } from "../../../fable_modules/FsSpreadsheet.4.1.0/Ranges/FsRangeBase.fs.js";
+import { singleton, append, toList, exists, map as map_1, delay, toArray } from "../../../fable_modules/fable-library.4.1.4/Seq.js";
+import { toFsCells as toFsCells_1, fromFsCells as fromFsCells_1 } from "./CompositeCell.js";
+import { rangeDouble } from "../../../fable_modules/fable-library.4.1.4/Range.js";
+import { CompositeColumn } from "../../ISA/ArcTypes/CompositeColumn.js";
+import { map as map_2 } from "../../../fable_modules/fable-library.4.1.4/Array.js";
+
+/**
+ * Checks if the column header is a deprecated IO Header. If so, fixes it.
+ * 
+ * The old format of IO Headers was only the type of IO so, e.g. "Source Name" or "Raw Data File".
+ * 
+ * A "Source Name" column will now be mapped to the propper "Input [Source Name]", and all other IO types will be mapped to "Output [<IO Type>]".
+ */
+export function fixDeprecatedIOHeader(col) {
+    const matchValue = IOType.ofString(col.Item(1).Value);
+    switch (matchValue.tag) {
+        case 6:
+            return col;
+        case 0: {
+            col.Item(1).SetValueAs(toString(new CompositeHeader(11, [new IOType(0, [])])));
+            return col;
+        }
+        default: {
+            col.Item(1).SetValueAs(toString(new CompositeHeader(12, [matchValue])));
+            return col;
+        }
+    }
+}
+
+export function fromFsColumns(columns) {
+    const header = fromFsCells(map((c) => c.Item(1), columns));
+    const l = FsAddress__get_RowNumber(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(item(0, columns)))) | 0;
+    const cells_2 = toArray(delay(() => map_1((i) => fromFsCells_1(map((c_1) => c_1.Item(i), columns)), rangeDouble(2, 1, l))));
+    return CompositeColumn.create(header, cells_2);
+}
+
+export function toFsColumns(column) {
+    const hasUnit = exists((c) => c.isUnitized, column.Cells);
+    const isTerm = column.Header.IsTermColumn;
+    const header = toFsCells(hasUnit, column.Header);
+    const cells = map_2((cell) => toFsCells_1(isTerm, hasUnit, cell), column.Cells);
+    if (hasUnit) {
+        return ofArray([toList(delay(() => append(singleton(item(0, header)), delay(() => map_1((i) => item(0, cells[i]), rangeDouble(0, 1, column.Cells.length - 1)))))), toList(delay(() => append(singleton(item(1, header)), delay(() => map_1((i_1) => item(1, cells[i_1]), rangeDouble(0, 1, column.Cells.length - 1)))))), toList(delay(() => append(singleton(item(2, header)), delay(() => map_1((i_2) => item(2, cells[i_2]), rangeDouble(0, 1, column.Cells.length - 1)))))), toList(delay(() => append(singleton(item(3, header)), delay(() => map_1((i_3) => item(3, cells[i_3]), rangeDouble(0, 1, column.Cells.length - 1))))))]);
+    }
+    else if (isTerm) {
+        return ofArray([toList(delay(() => append(singleton(item(0, header)), delay(() => map_1((i_4) => item(0, cells[i_4]), rangeDouble(0, 1, column.Cells.length - 1)))))), toList(delay(() => append(singleton(item(1, header)), delay(() => map_1((i_5) => item(1, cells[i_5]), rangeDouble(0, 1, column.Cells.length - 1)))))), toList(delay(() => append(singleton(item(2, header)), delay(() => map_1((i_6) => item(2, cells[i_6]), rangeDouble(0, 1, column.Cells.length - 1))))))]);
+    }
+    else {
+        return singleton_1(toList(delay(() => append(singleton(item(0, header)), delay(() => map_1((i_7) => item(0, cells[i_7]), rangeDouble(0, 1, column.Cells.length - 1)))))));
+    }
+}
+

package/ISA/ISA.Spreadsheet/AnnotationTable/CompositeHeader.js

@@ -0,0 +1,478 @@
+import { printf, toFail } from "../../../fable_modules/fable-library.4.1.4/String.js";
+import { singleton, tail, head, isEmpty, map } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { OntologyAnnotation } from "../../ISA/JsonTypes/OntologyAnnotation.js";
+import { ActivePatterns_$007COutputColumnHeader$007C_$007C, ActivePatterns_$007CInputColumnHeader$007C_$007C, tryParseComponentColumnHeader, tryParseCharacteristicColumnHeader, tryParseFactorColumnHeader, tryParseParameterColumnHeader, ActivePatterns_$007CUnitColumnHeader$007C_$007C, ActivePatterns_$007CTANColumnHeader$007C_$007C, ActivePatterns_$007CTSRColumnHeader$007C_$007C } from "../../ISA/Regex.js";
+import { IOType, CompositeHeader } from "../../ISA/ArcTypes/CompositeHeader.js";
+import { FsCell } from "../../../fable_modules/FsSpreadsheet.4.1.0/Cells/FsCell.fs.js";
+import { toString } from "../../../fable_modules/fable-library.4.1.4/Types.js";
+import { empty, singleton as singleton_1, append, delay, toList } from "../../../fable_modules/fable-library.4.1.4/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, cells) {
+    const $007CAC$007C_$007C = categoryParser;
+    const cellValues = map((c) => c.Value, cells);
+    let matchResult, name;
+    if (!isEmpty(cellValues)) {
+        const activePatternResult = $007CAC$007C_$007C(head(cellValues));
+        if (activePatternResult != null) {
+            if (isEmpty(tail(cellValues))) {
+                matchResult = 0;
+                name = activePatternResult;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return f(OntologyAnnotation.fromString(name));
+        default: {
+            let matchResult_1, name_1, term1, term2;
+            if (!isEmpty(cellValues)) {
+                const activePatternResult_1 = $007CAC$007C_$007C(head(cellValues));
+                if (activePatternResult_1 != null) {
+                    if (!isEmpty(tail(cellValues))) {
+                        const activePatternResult_2 = ActivePatterns_$007CTSRColumnHeader$007C_$007C(head(tail(cellValues)));
+                        if (activePatternResult_2 != null) {
+                            if (!isEmpty(tail(tail(cellValues)))) {
+                                const activePatternResult_3 = ActivePatterns_$007CTANColumnHeader$007C_$007C(head(tail(tail(cellValues))));
+                                if (activePatternResult_3 != null) {
+                                    if (!isEmpty(tail(tail(tail(cellValues))))) {
+                                        const activePatternResult_4 = ActivePatterns_$007CTANColumnHeader$007C_$007C(head(tail(tail(tail(cellValues)))));
+                                        if (activePatternResult_4 != null) {
+                                            if (isEmpty(tail(tail(tail(tail(cellValues)))))) {
+                                                const activePatternResult_5 = ActivePatterns_$007CTSRColumnHeader$007C_$007C(head(tail(tail(cellValues))));
+                                                if (activePatternResult_5 != null) {
+                                                    if (ActivePatterns_$007CUnitColumnHeader$007C_$007C(head(tail(cellValues))) != null) {
+                                                        matchResult_1 = 0;
+                                                        name_1 = activePatternResult_1;
+                                                        term1 = activePatternResult_5;
+                                                        term2 = activePatternResult_4;
+                                                    }
+                                                    else {
+                                                        matchResult_1 = 1;
+                                                    }
+                                                }
+                                                else {
+                                                    matchResult_1 = 1;
+                                                }
+                                            }
+                                            else {
+                                                matchResult_1 = 1;
+                                            }
+                                        }
+                                        else {
+                                            matchResult_1 = 1;
+                                        }
+                                    }
+                                    else {
+                                        matchResult_1 = 0;
+                                        name_1 = activePatternResult_1;
+                                        term1 = activePatternResult_2;
+                                        term2 = activePatternResult_3;
+                                    }
+                                }
+                                else {
+                                    const activePatternResult_7 = ActivePatterns_$007CTSRColumnHeader$007C_$007C(head(tail(tail(cellValues))));
+                                    if (activePatternResult_7 != null) {
+                                        if (!isEmpty(tail(tail(tail(cellValues))))) {
+                                            const activePatternResult_8 = ActivePatterns_$007CTANColumnHeader$007C_$007C(head(tail(tail(tail(cellValues)))));
+                                            if (activePatternResult_8 != null) {
+                                                if (isEmpty(tail(tail(tail(tail(cellValues)))))) {
+                                                    if (ActivePatterns_$007CUnitColumnHeader$007C_$007C(head(tail(cellValues))) != null) {
+                                                        matchResult_1 = 0;
+                                                        name_1 = activePatternResult_1;
+                                                        term1 = activePatternResult_7;
+                                                        term2 = activePatternResult_8;
+                                                    }
+                                                    else {
+                                                        matchResult_1 = 1;
+                                                    }
+                                                }
+                                                else {
+                                                    matchResult_1 = 1;
+                                                }
+                                            }
+                                            else {
+                                                matchResult_1 = 1;
+                                            }
+                                        }
+                                        else {
+                                            matchResult_1 = 1;
+                                        }
+                                    }
+                                    else {
+                                        matchResult_1 = 1;
+                                    }
+                                }
+                            }
+                            else {
+                                matchResult_1 = 1;
+                            }
+                        }
+                        else if (ActivePatterns_$007CUnitColumnHeader$007C_$007C(head(tail(cellValues))) != null) {
+                            if (!isEmpty(tail(tail(cellValues)))) {
+                                const activePatternResult_11 = ActivePatterns_$007CTSRColumnHeader$007C_$007C(head(tail(tail(cellValues))));
+                                if (activePatternResult_11 != null) {
+                                    if (!isEmpty(tail(tail(tail(cellValues))))) {
+                                        const activePatternResult_12 = ActivePatterns_$007CTANColumnHeader$007C_$007C(head(tail(tail(tail(cellValues)))));
+                                        if (activePatternResult_12 != null) {
+                                            if (isEmpty(tail(tail(tail(tail(cellValues)))))) {
+                                                matchResult_1 = 0;
+                                                name_1 = activePatternResult_1;
+                                                term1 = activePatternResult_11;
+                                                term2 = activePatternResult_12;
+                                            }
+                                            else {
+                                                matchResult_1 = 1;
+                                            }
+                                        }
+                                        else {
+                                            matchResult_1 = 1;
+                                        }
+                                    }
+                                    else {
+                                        matchResult_1 = 1;
+                                    }
+                                }
+                                else {
+                                    matchResult_1 = 1;
+                                }
+                            }
+                            else {
+                                matchResult_1 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_1 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+            }
+            else {
+                matchResult_1 = 1;
+            }
+            switch (matchResult_1) {
+                case 0: {
+                    const term = ActivePattern_mergeIDInfo(term1.IDSpace, term1.LocalID, term2.IDSpace, term2.LocalID);
+                    return f(OntologyAnnotation.fromString(name_1, term.TermSourceRef, term.TermAccessionNumber));
+                }
+                default:
+                    return void 0;
+            }
+        }
+    }
+}
+
+export function ActivePattern_$007CParameter$007C_$007C(cells) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C(tryParseParameterColumnHeader, (arg) => (new CompositeHeader(3, [arg])), cells);
+    if (activePatternResult != null) {
+        const r = activePatternResult;
+        return r;
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function ActivePattern_$007CFactor$007C_$007C(cells) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C(tryParseFactorColumnHeader, (arg) => (new CompositeHeader(2, [arg])), cells);
+    if (activePatternResult != null) {
+        const r = activePatternResult;
+        return r;
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function ActivePattern_$007CCharacteristic$007C_$007C(cells) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C(tryParseCharacteristicColumnHeader, (arg) => (new CompositeHeader(1, [arg])), cells);
+    if (activePatternResult != null) {
+        const r = activePatternResult;
+        return r;
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function ActivePattern_$007CComponent$007C_$007C(cells) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C(tryParseComponentColumnHeader, (arg) => (new CompositeHeader(0, [arg])), cells);
+    if (activePatternResult != null) {
+        const r = activePatternResult;
+        return r;
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function ActivePattern_$007CInput$007C_$007C(cells) {
+    const cellValues = map((c) => c.Value, cells);
+    let matchResult, ioType;
+    if (!isEmpty(cellValues)) {
+        const activePatternResult = ActivePatterns_$007CInputColumnHeader$007C_$007C(head(cellValues));
+        if (activePatternResult != null) {
+            if (isEmpty(tail(cellValues))) {
+                matchResult = 0;
+                ioType = activePatternResult;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new CompositeHeader(11, [IOType.ofString(ioType)]);
+        default:
+            return void 0;
+    }
+}
+
+export function ActivePattern_$007COutput$007C_$007C(cells) {
+    const cellValues = map((c) => c.Value, cells);
+    let matchResult, ioType;
+    if (!isEmpty(cellValues)) {
+        const activePatternResult = ActivePatterns_$007COutputColumnHeader$007C_$007C(head(cellValues));
+        if (activePatternResult != null) {
+            if (isEmpty(tail(cellValues))) {
+                matchResult = 0;
+                ioType = activePatternResult;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new CompositeHeader(12, [IOType.ofString(ioType)]);
+        default:
+            return void 0;
+    }
+}
+
+export function ActivePattern_$007CProtocolHeader$007C_$007C(cells) {
+    const cellValues = map((c) => c.Value, cells);
+    let matchResult;
+    if (!isEmpty(cellValues)) {
+        switch (head(cellValues)) {
+            case "Protocol Type": {
+                matchResult = 0;
+                break;
+            }
+            case "Protocol REF": {
+                if (isEmpty(tail(cellValues))) {
+                    matchResult = 1;
+                }
+                else {
+                    matchResult = 7;
+                }
+                break;
+            }
+            case "Protocol Description": {
+                if (isEmpty(tail(cellValues))) {
+                    matchResult = 2;
+                }
+                else {
+                    matchResult = 7;
+                }
+                break;
+            }
+            case "Protocol Uri": {
+                if (isEmpty(tail(cellValues))) {
+                    matchResult = 3;
+                }
+                else {
+                    matchResult = 7;
+                }
+                break;
+            }
+            case "Protocol Version": {
+                if (isEmpty(tail(cellValues))) {
+                    matchResult = 4;
+                }
+                else {
+                    matchResult = 7;
+                }
+                break;
+            }
+            case "Performer": {
+                if (isEmpty(tail(cellValues))) {
+                    matchResult = 5;
+                }
+                else {
+                    matchResult = 7;
+                }
+                break;
+            }
+            case "Date": {
+                if (isEmpty(tail(cellValues))) {
+                    matchResult = 6;
+                }
+                else {
+                    matchResult = 7;
+                }
+                break;
+            }
+            default:
+                matchResult = 7;
+        }
+    }
+    else {
+        matchResult = 7;
+    }
+    switch (matchResult) {
+        case 0:
+            return new CompositeHeader(4, []);
+        case 1:
+            return new CompositeHeader(8, []);
+        case 2:
+            return new CompositeHeader(5, []);
+        case 3:
+            return new CompositeHeader(6, []);
+        case 4:
+            return new CompositeHeader(7, []);
+        case 5:
+            return new CompositeHeader(9, []);
+        case 6:
+            return new CompositeHeader(10, []);
+        default:
+            return void 0;
+    }
+}
+
+export function ActivePattern_$007CFreeText$007C_$007C(cells) {
+    const cellValues = map((c) => c.Value, cells);
+    let matchResult, text;
+    if (!isEmpty(cellValues)) {
+        if (isEmpty(tail(cellValues))) {
+            matchResult = 0;
+            text = head(cellValues);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new CompositeHeader(13, [text]);
+        default:
+            return void 0;
+    }
+}
+
+export function fromFsCells(cells) {
+    const activePatternResult = ActivePattern_$007CParameter$007C_$007C(cells);
+    if (activePatternResult != null) {
+        const p = activePatternResult;
+        return p;
+    }
+    else {
+        const activePatternResult_1 = ActivePattern_$007CFactor$007C_$007C(cells);
+        if (activePatternResult_1 != null) {
+            const f = activePatternResult_1;
+            return f;
+        }
+        else {
+            const activePatternResult_2 = ActivePattern_$007CCharacteristic$007C_$007C(cells);
+            if (activePatternResult_2 != null) {
+                const c = activePatternResult_2;
+                return c;
+            }
+            else {
+                const activePatternResult_3 = ActivePattern_$007CComponent$007C_$007C(cells);
+                if (activePatternResult_3 != null) {
+                    const c_1 = activePatternResult_3;
+                    return c_1;
+                }
+                else {
+                    const activePatternResult_4 = ActivePattern_$007CInput$007C_$007C(cells);
+                    if (activePatternResult_4 != null) {
+                        const i = activePatternResult_4;
+                        return i;
+                    }
+                    else {
+                        const activePatternResult_5 = ActivePattern_$007COutput$007C_$007C(cells);
+                        if (activePatternResult_5 != null) {
+                            const o = activePatternResult_5;
+                            return o;
+                        }
+                        else {
+                            const activePatternResult_6 = ActivePattern_$007CProtocolHeader$007C_$007C(cells);
+                            if (activePatternResult_6 != null) {
+                                const ph = activePatternResult_6;
+                                return ph;
+                            }
+                            else {
+                                const activePatternResult_7 = ActivePattern_$007CFreeText$007C_$007C(cells);
+                                if (activePatternResult_7 != null) {
+                                    const ft = activePatternResult_7;
+                                    return ft;
+                                }
+                                else {
+                                    return toFail(printf("Could not parse header group %O"))(cells);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+export function toFsCells(hasUnit, header) {
+    if (header.IsSingleColumn) {
+        return singleton(new FsCell(toString(header)));
+    }
+    else if (header.IsTermColumn) {
+        return toList(delay(() => append(singleton_1(new FsCell(toString(header))), delay(() => append(hasUnit ? singleton_1(new FsCell("Unit")) : empty(), delay(() => append(singleton_1(new FsCell(`Term Source REF (${header.GetColumnAccessionShort})`)), delay(() => singleton_1(new FsCell(`Term Accession Number (${header.GetColumnAccessionShort})`))))))))));
+    }
+    else {
+        return toFail(printf("header %O is neither single nor term column"))(header);
+    }
+}
+

package/ISA/ISA.Spreadsheet/ArcAssay.js

@@ -0,0 +1,150 @@
+import { FsWorksheet } from "../../fable_modules/FsSpreadsheet.4.1.0/FsWorksheet.fs.js";
+import { iterate, isEmpty as isEmpty_1, choose, tryHead, head, exists, map, singleton, append, delay, iterateIndexed } from "../../fable_modules/fable-library.4.1.4/Seq.js";
+import { SparseRowModule_tryGetValueAt, SparseRowModule_fromFsRow, SparseRowModule_fromValues, SparseRowModule_writeToSheet } from "./Metadata/SparseTable.js";
+import { fromRows as fromRows_1, toRows as toRows_1 } from "./Metadata/Assays.js";
+import { empty, isEmpty, toArray, ofArray, singleton as singleton_1 } from "../../fable_modules/fable-library.4.1.4/List.js";
+import { fromRows as fromRows_2, toRows as toRows_2 } from "./Metadata/Contacts.js";
+import { getEnumerator } from "../../fable_modules/fable-library.4.1.4/Util.js";
+import { ArcAssay } from "../ISA/ArcTypes/ArcTypes.js";
+import { createMissingIdentifier } from "../ISA/Identifier.js";
+import { defaultArg } from "../../fable_modules/fable-library.4.1.4/Option.js";
+import { printf, toConsole } from "../../fable_modules/fable-library.4.1.4/String.js";
+import { toFsWorksheet, tryFromFsWorksheet } from "./AnnotationTable/ArcTable.js";
+import { FsWorkbook } from "../../fable_modules/FsSpreadsheet.4.1.0/FsWorkbook.fs.js";
+
+export function toMetadataSheet(assay) {
+    let assay_1;
+    const sheet = new FsWorksheet("isa_assay");
+    iterateIndexed((rowI, r) => {
+        SparseRowModule_writeToSheet(rowI + 1, r, sheet);
+    }, (assay_1 = assay, delay(() => append(singleton(SparseRowModule_fromValues(["ASSAY"])), delay(() => append(toRows_1("Assay", singleton_1(assay_1)), delay(() => append(singleton(SparseRowModule_fromValues(["ASSAY PERFORMERS"])), delay(() => toRows_2("Assay Person", ofArray(assay_1.Performers)))))))))));
+    return sheet;
+}
+
+export function fromMetadataSheet(sheet) {
+    const rows_1 = map(SparseRowModule_fromFsRow, sheet.Rows);
+    const patternInput = exists((row) => {
+        const s = head(row)[1];
+        return s.indexOf("Assay") === 0;
+    }, rows_1) ? ["Assay", "Assay Person"] : [void 0, void 0];
+    const en = getEnumerator(rows_1);
+    const loop = (lastLine_mut, assays_mut, contacts_mut, lineNumber_mut) => {
+        let k;
+        loop:
+        while (true) {
+            const lastLine = lastLine_mut, assays = assays_mut, contacts = contacts_mut, lineNumber = lineNumber_mut;
+            let matchResult, k_2, k_3, k_4;
+            if (lastLine != null) {
+                if ((k = lastLine, (k === "ASSAY") ? true : (k === "ASSAY METADATA"))) {
+                    matchResult = 0;
+                    k_2 = lastLine;
+                }
+                else if (lastLine === "ASSAY PERFORMERS") {
+                    matchResult = 1;
+                    k_3 = lastLine;
+                }
+                else {
+                    matchResult = 2;
+                    k_4 = lastLine;
+                }
+            }
+            else {
+                matchResult = 2;
+                k_4 = lastLine;
+            }
+            switch (matchResult) {
+                case 0: {
+                    const patternInput_1 = fromRows_1(patternInput[0], lineNumber + 1, en);
+                    lastLine_mut = patternInput_1[0];
+                    assays_mut = patternInput_1[3];
+                    contacts_mut = contacts;
+                    lineNumber_mut = patternInput_1[1];
+                    continue loop;
+                }
+                case 1: {
+                    const patternInput_2 = fromRows_2(patternInput[1], lineNumber + 1, en);
+                    lastLine_mut = patternInput_2[0];
+                    assays_mut = assays;
+                    contacts_mut = patternInput_2[3];
+                    lineNumber_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 arg = toArray(contacts_2);
+                            const arg_1 = defaultArg(tryHead(assays_2), ArcAssay.create(createMissingIdentifier()));
+                            return ArcAssay.setPerformers(arg, arg_1);
+                        }
+                    }
+                }
+            }
+            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");
+    }
+}
+
+/**
+ * Reads an assay from a spreadsheet
+ */
+export function fromFsWorkbook(doc) {
+    let assayMetaData;
+    const matchValue = doc.TryGetWorksheetByName("isa_assay");
+    if (matchValue == null) {
+        const matchValue_1 = doc.TryGetWorksheetByName("Assay");
+        if (matchValue_1 == null) {
+            toConsole(printf("Cannot retrieve metadata: Assay file does not contain \"%s\" or \"%s\" sheet."))("isa_assay")("Assay");
+            assayMetaData = ArcAssay.create(createMissingIdentifier());
+        }
+        else {
+            assayMetaData = fromMetadataSheet(matchValue_1);
+        }
+    }
+    else {
+        assayMetaData = fromMetadataSheet(matchValue);
+    }
+    const sheets = choose(tryFromFsWorksheet, doc.GetWorksheets());
+    if (isEmpty_1(sheets)) {
+        return assayMetaData;
+    }
+    else {
+        assayMetaData.Tables = Array.from(sheets);
+        return assayMetaData;
+    }
+}
+
+export function toFsWorkbook(assay) {
+    const doc = new FsWorkbook();
+    const metaDataSheet = toMetadataSheet(assay);
+    doc.AddWorksheet(metaDataSheet);
+    iterate((arg_1) => {
+        const arg = toFsWorksheet(arg_1);
+        doc.AddWorksheet(arg);
+    }, assay.Tables);
+    return doc;
+}
+