@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/esm/ts/Spreadsheet/DataMapTable/DataMapHeader.js

@@ -0,0 +1,463 @@
+import { tryFindIndex, tail, head, isEmpty, item, map } from "@fable-org/fable-library-js/List.js";
+import { FsCell } from "../../fable_modules/FsSpreadsheet.6.3.1/Cells/FsCell.fs.js";
+import { value, unwrap, map as map_1 } from "@fable-org/fable-library-js/Option.js";
+import { OntologyAnnotation } from "../../Core/OntologyAnnotation.js";
+import { Data } from "../../Core/Data.js";
+import { DataContext__set_Label_6DFDD678, DataContext__set_GeneratedBy_6DFDD678, DataContext__set_Description_6DFDD678, DataContext__set_ObjectType_279AAFF2, DataContext__set_Unit_279AAFF2, DataContext__set_Explication_279AAFF2 } from "../../Core/DataContext.js";
+import { Option_fromValueWithDefault } from "../../Core/Helper/Collections.js";
+import { Comment$ } from "../../Core/Comment.js";
+import { ActivePatterns_$007CComment$007C_$007C } from "../../Core/Helper/Regex.js";
+import { printf, toFail, join } from "@fable-org/fable-library-js/String.js";
+import { map as map_2, append, delay, toList } from "@fable-org/fable-library-js/Seq.js";
+export function ActivePattern_ontologyAnnotationFromFsCells(tsrCol, tanCol, cells) {
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    const tsr = map_1((i) => item(i, cellValues), tsrCol);
+    const tan = map_1((i_1) => item(i_1, cellValues), tanCol);
+    return new OntologyAnnotation(item(0, cellValues), unwrap(tsr), unwrap(tan));
+}
+export function ActivePattern_freeTextFromFsCells(cells) {
+    return item(0, map((c) => c.ValueAsString(), cells));
+}
+export function ActivePattern_dataFromFsCells(format, selectorFormat, cells) {
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    const format_1 = map_1((i) => item(i, cellValues), format);
+    const selectorFormat_1 = map_1((i_1) => item(i_1, cellValues), selectorFormat);
+    return new Data(undefined, item(0, cellValues), undefined, unwrap(format_1), unwrap(selectorFormat_1));
+}
+export function ActivePattern_$007CTerm$007C_$007C(categoryString, cells) {
+    const $007CAC$007C_$007C = (s) => {
+        if (s === categoryString) {
+            return 1;
+        }
+        else {
+            return undefined;
+        }
+    };
+    const $007CTSRColumnHeaderRaw$007C_$007C = (s_1) => {
+        if (s_1.startsWith("Term Source REF")) {
+            return s_1;
+        }
+        else {
+            return undefined;
+        }
+    };
+    const $007CTANColumnHeaderRaw$007C_$007C = (s_2) => {
+        if (s_2.startsWith("Term Accession Number")) {
+            return s_2;
+        }
+        else {
+            return undefined;
+        }
+    };
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    let matchResult, header;
+    if (!isEmpty(cellValues)) {
+        const activePatternResult = $007CAC$007C_$007C(head(cellValues));
+        if (activePatternResult != null) {
+            if (isEmpty(tail(cellValues))) {
+                matchResult = 0;
+                header = value(activePatternResult);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return (cells_1) => ActivePattern_ontologyAnnotationFromFsCells(undefined, undefined, cells_1);
+        default: {
+            let matchResult_1, header_1;
+            if (!isEmpty(cellValues)) {
+                const activePatternResult_1 = $007CAC$007C_$007C(head(cellValues));
+                if (activePatternResult_1 != null) {
+                    if (!isEmpty(tail(cellValues))) {
+                        if ($007CTSRColumnHeaderRaw$007C_$007C(head(tail(cellValues))) != null) {
+                            if (!isEmpty(tail(tail(cellValues)))) {
+                                if ($007CTANColumnHeaderRaw$007C_$007C(head(tail(tail(cellValues)))) != null) {
+                                    if (isEmpty(tail(tail(tail(cellValues))))) {
+                                        matchResult_1 = 0;
+                                        header_1 = value(activePatternResult_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:
+                    return (cells_2) => ActivePattern_ontologyAnnotationFromFsCells(1, 2, cells_2);
+                default: {
+                    let matchResult_2, header_2;
+                    if (!isEmpty(cellValues)) {
+                        const activePatternResult_4 = $007CAC$007C_$007C(head(cellValues));
+                        if (activePatternResult_4 != null) {
+                            if (!isEmpty(tail(cellValues))) {
+                                if ($007CTANColumnHeaderRaw$007C_$007C(head(tail(cellValues))) != null) {
+                                    if (!isEmpty(tail(tail(cellValues)))) {
+                                        if ($007CTSRColumnHeaderRaw$007C_$007C(head(tail(tail(cellValues)))) != null) {
+                                            if (isEmpty(tail(tail(tail(cellValues))))) {
+                                                matchResult_2 = 0;
+                                                header_2 = value(activePatternResult_4);
+                                            }
+                                            else {
+                                                matchResult_2 = 1;
+                                            }
+                                        }
+                                        else {
+                                            matchResult_2 = 1;
+                                        }
+                                    }
+                                    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:
+                            return (cells_3) => ActivePattern_ontologyAnnotationFromFsCells(2, 1, cells_3);
+                        default:
+                            return undefined;
+                    }
+                }
+            }
+        }
+    }
+}
+export function ActivePattern_$007CExplication$007C_$007C(cells) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C("Explication", cells);
+    if (activePatternResult != null) {
+        const r = value(activePatternResult);
+        return (dc) => ((cells_1) => {
+            DataContext__set_Explication_279AAFF2(dc, r(cells_1));
+            return dc;
+        });
+    }
+    else {
+        return undefined;
+    }
+}
+export function ActivePattern_$007CUnit$007C_$007C(cells) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C("Unit", cells);
+    if (activePatternResult != null) {
+        const r = value(activePatternResult);
+        return (dc) => ((cells_1) => {
+            DataContext__set_Unit_279AAFF2(dc, r(cells_1));
+            return dc;
+        });
+    }
+    else {
+        return undefined;
+    }
+}
+export function ActivePattern_$007CObjectType$007C_$007C(cells) {
+    const activePatternResult = ActivePattern_$007CTerm$007C_$007C("Object Type", cells);
+    if (activePatternResult != null) {
+        const r = value(activePatternResult);
+        return (dc) => ((cells_1) => {
+            DataContext__set_ObjectType_279AAFF2(dc, r(cells_1));
+            return dc;
+        });
+    }
+    else {
+        return undefined;
+    }
+}
+export function ActivePattern_$007CDescription$007C_$007C(cells) {
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    let matchResult;
+    if (!isEmpty(cellValues)) {
+        if (head(cellValues) === "Description") {
+            if (isEmpty(tail(cellValues))) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return (dc) => ((cells_1) => {
+                DataContext__set_Description_6DFDD678(dc, Option_fromValueWithDefault("", ActivePattern_freeTextFromFsCells(cells_1)));
+                return dc;
+            });
+        default:
+            return undefined;
+    }
+}
+export function ActivePattern_$007CGeneratedBy$007C_$007C(cells) {
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    let matchResult;
+    if (!isEmpty(cellValues)) {
+        if (head(cellValues) === "Generated By") {
+            if (isEmpty(tail(cellValues))) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return (dc) => ((cells_1) => {
+                DataContext__set_GeneratedBy_6DFDD678(dc, Option_fromValueWithDefault("", ActivePattern_freeTextFromFsCells(cells_1)));
+                return dc;
+            });
+        default:
+            return undefined;
+    }
+}
+export function ActivePattern_$007CLabel$007C_$007C(cells) {
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    let matchResult;
+    if (!isEmpty(cellValues)) {
+        if (head(cellValues) === "Label") {
+            if (isEmpty(tail(cellValues))) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return (dc) => ((cells_1) => {
+                DataContext__set_Label_6DFDD678(dc, Option_fromValueWithDefault("", ActivePattern_freeTextFromFsCells(cells_1)));
+                return dc;
+            });
+        default:
+            return undefined;
+    }
+}
+export function ActivePattern_$007CData$007C_$007C(cells) {
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    let matchResult, cols;
+    if (!isEmpty(cellValues)) {
+        if (head(cellValues) === "Data") {
+            matchResult = 0;
+            cols = tail(cellValues);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return (dc) => ((cells_1) => {
+                const d = ActivePattern_dataFromFsCells(map_1((y) => (1 + y), tryFindIndex((s) => s.startsWith("Data Format"), cols)), map_1((y_1) => (1 + y_1), tryFindIndex((s_1) => s_1.startsWith("Data Selector Format"), cols)), cells_1);
+                dc.FilePath = d.FilePath;
+                dc.Selector = d.Selector;
+                dc.Format = d.Format;
+                dc.SelectorFormat = d.SelectorFormat;
+                return dc;
+            });
+        default:
+            return undefined;
+    }
+}
+export function ActivePattern_$007CComment$007C_$007C(cells) {
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    let matchResult, key;
+    if (!isEmpty(cellValues)) {
+        const activePatternResult = ActivePatterns_$007CComment$007C_$007C(head(cellValues));
+        if (activePatternResult != null) {
+            if (isEmpty(tail(cellValues))) {
+                matchResult = 0;
+                key = value(activePatternResult);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return (dc) => ((cells_1) => {
+                const comment = item(0, map((c_1) => c_1.ValueAsString(), cells_1));
+                void (dc.Comments.push(Comment$.create(key, comment)));
+                return dc;
+            });
+        default:
+            return undefined;
+    }
+}
+export function ActivePattern_$007CFreetext$007C_$007C(cells) {
+    const cellValues = map((c) => c.ValueAsString(), cells);
+    let matchResult, key;
+    if (!isEmpty(cellValues)) {
+        if (isEmpty(tail(cellValues))) {
+            matchResult = 0;
+            key = head(cellValues);
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return (dc) => ((cells_1) => {
+                const comment = item(0, map((c_1) => c_1.ValueAsString(), cells_1));
+                void (dc.Comments.push(Comment$.create(key, comment)));
+                return dc;
+            });
+        default:
+            return undefined;
+    }
+}
+export function fromFsCells(cells) {
+    let matchResult, r;
+    const activePatternResult = ActivePattern_$007CExplication$007C_$007C(cells);
+    if (activePatternResult != null) {
+        matchResult = 0;
+        r = value(activePatternResult);
+    }
+    else {
+        const activePatternResult_1 = ActivePattern_$007CUnit$007C_$007C(cells);
+        if (activePatternResult_1 != null) {
+            matchResult = 0;
+            r = value(activePatternResult_1);
+        }
+        else {
+            const activePatternResult_2 = ActivePattern_$007CObjectType$007C_$007C(cells);
+            if (activePatternResult_2 != null) {
+                matchResult = 0;
+                r = value(activePatternResult_2);
+            }
+            else {
+                const activePatternResult_3 = ActivePattern_$007CDescription$007C_$007C(cells);
+                if (activePatternResult_3 != null) {
+                    matchResult = 0;
+                    r = value(activePatternResult_3);
+                }
+                else {
+                    const activePatternResult_4 = ActivePattern_$007CGeneratedBy$007C_$007C(cells);
+                    if (activePatternResult_4 != null) {
+                        matchResult = 0;
+                        r = value(activePatternResult_4);
+                    }
+                    else {
+                        const activePatternResult_5 = ActivePattern_$007CLabel$007C_$007C(cells);
+                        if (activePatternResult_5 != null) {
+                            matchResult = 0;
+                            r = value(activePatternResult_5);
+                        }
+                        else {
+                            const activePatternResult_6 = ActivePattern_$007CData$007C_$007C(cells);
+                            if (activePatternResult_6 != null) {
+                                matchResult = 0;
+                                r = value(activePatternResult_6);
+                            }
+                            else {
+                                const activePatternResult_7 = ActivePattern_$007CComment$007C_$007C(cells);
+                                if (activePatternResult_7 != null) {
+                                    matchResult = 0;
+                                    r = value(activePatternResult_7);
+                                }
+                                else {
+                                    const activePatternResult_8 = ActivePattern_$007CFreetext$007C_$007C(cells);
+                                    if (activePatternResult_8 != null) {
+                                        matchResult = 0;
+                                        r = value(activePatternResult_8);
+                                    }
+                                    else {
+                                        matchResult = 1;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    switch (matchResult) {
+        case 0:
+            return (dc) => ((cells_1) => r(dc)(cells_1));
+        default: {
+            const arg = join(", ", map((c) => c.ValueAsString(), cells));
+            const clo_1 = toFail(printf("Could not parse data map column: %s"))(arg);
+            return (arg_1) => {
+                const clo_2 = clo_1(arg_1);
+                return clo_2;
+            };
+        }
+    }
+}
+export function toFsCells(commentKeys) {
+    return toList(delay(() => append([new FsCell("Data"), new FsCell("Data Format"), new FsCell("Data Selector Format")], delay(() => append([new FsCell("Explication"), new FsCell("Term Source REF"), new FsCell("Term Accession Number")], delay(() => append([new FsCell("Unit"), new FsCell("Term Source REF"), new FsCell("Term Accession Number")], delay(() => append([new FsCell("Object Type"), new FsCell("Term Source REF"), new FsCell("Term Accession Number")], delay(() => append([new FsCell("Description")], delay(() => append([new FsCell("Generated By")], delay(() => append([new FsCell("Label")], delay(() => map_2((ck) => (new FsCell(ck)), commentKeys)))))))))))))))));
+}

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

@@ -0,0 +1,97 @@
+import { iterateIndexed, head, length, iterate, exists, ofArray } from "@fable-org/fable-library-js/List.js";
+import { Aux_List_groupWhen } from "../AnnotationTable/ArcTable.js";
+import { toList, map, delay, toArray, item, tryFind } from "@fable-org/fable-library-js/Seq.js";
+import { FsWorksheet } from "../../fable_modules/FsSpreadsheet.6.3.1/FsWorksheet.fs.js";
+import { value as value_1 } from "@fable-org/fable-library-js/Option.js";
+import { DataContext_$ctor_Z780A8A2A } from "../../Core/DataContext.js";
+import { rangeDouble } from "@fable-org/fable-library-js/Range.js";
+import { toFsColumns, setFromFsColumns } from "./DataMapColumn.js";
+import { printf, toFail } from "@fable-org/fable-library-js/String.js";
+import { DataMap__get_DataContexts, DataMap_$ctor_4E3220A7 } from "../../Core/DataMap.js";
+import { FsRangeAddress_$ctor_7E77A4A0 } from "../../fable_modules/FsSpreadsheet.6.3.1/Ranges/FsRangeAddress.fs.js";
+import { FsAddress_$ctor_Z37302880 } from "../../fable_modules/FsSpreadsheet.6.3.1/FsAddress.fs.js";
+import { Dictionary_tryGet } from "../../fable_modules/FsSpreadsheet.6.3.1/Cells/FsCellsCollection.fs.js";
+import { addToDict } from "@fable-org/fable-library-js/MapUtil.js";
+import { FsRangeBase__Cell_Z3407A44B } from "../../fable_modules/FsSpreadsheet.6.3.1/Ranges/FsRangeBase.fs.js";
+export const helperColumnStrings = ofArray(["Term Source REF", "Term Accession Number", "Data Format", "Data Selector Format"]);
+export function groupColumnsByHeader(columns) {
+    return Aux_List_groupWhen((c) => {
+        const v = c.Item(1).ValueAsString();
+        return !exists((s) => v.startsWith(s), helperColumnStrings);
+    }, columns);
+}
+/**
+ * Returns the annotation table of the worksheet if it exists, else returns None
+ */
+export function tryDataMapTable(sheet) {
+    return tryFind((t) => t.Name.startsWith("datamapTable"), sheet.Tables);
+}
+/**
+ * Groups and parses a collection of single columns into the according ISA composite columns
+ */
+export function composeColumns(columns) {
+    const l = (item(0, columns).MaxRowIndex - 1) | 0;
+    const dc = Array.from(toArray(delay(() => map((i) => DataContext_$ctor_Z780A8A2A(), rangeDouble(0, 1, l - 1)))));
+    iterate((arg) => {
+        setFromFsColumns(dc, arg);
+    }, groupColumnsByHeader(toList(columns)));
+    return dc;
+}
+/**
+ * Returns the protocol described by the headers and a function for parsing the values of the matrix to the processes of this protocol
+ */
+export function tryFromFsWorksheet(sheet) {
+    try {
+        const matchValue = tryDataMapTable(sheet);
+        if (matchValue == null) {
+            return undefined;
+        }
+        else {
+            const t = value_1(matchValue);
+            return DataMap_$ctor_4E3220A7(composeColumns(t.GetColumns(sheet.CellCollection)));
+        }
+    }
+    catch (err) {
+        const arg = sheet.Name;
+        const arg_1 = err.message;
+        return toFail(printf("Could not parse datamap table with name \"%s\":\n%s"))(arg)(arg_1);
+    }
+}
+export function toFsWorksheet(table) {
+    const stringCount = new Map([]);
+    const ws = new FsWorksheet("isa_datamap");
+    if (DataMap__get_DataContexts(table).length === 0) {
+        return ws;
+    }
+    else {
+        const columns = toFsColumns(DataMap__get_DataContexts(table));
+        const maxRow = length(head(columns)) | 0;
+        const maxCol = length(columns) | 0;
+        const fsTable = ws.Table("datamapTable", FsRangeAddress_$ctor_7E77A4A0(FsAddress_$ctor_Z37302880(1, 1), FsAddress_$ctor_Z37302880(maxRow, maxCol)));
+        iterateIndexed((colI, col) => {
+            iterateIndexed((rowI, cell) => {
+                let value;
+                const v = cell.ValueAsString();
+                if (rowI === 0) {
+                    const matchValue = Dictionary_tryGet(v, stringCount);
+                    if (matchValue == null) {
+                        addToDict(stringCount, cell.ValueAsString(), "");
+                        value = v;
+                    }
+                    else {
+                        const spaces = value_1(matchValue);
+                        stringCount.set(v, spaces + " ");
+                        value = ((v + " ") + spaces);
+                    }
+                }
+                else {
+                    value = v;
+                }
+                const address = FsAddress_$ctor_Z37302880(rowI + 1, colI + 1);
+                FsRangeBase__Cell_Z3407A44B(fsTable, address, ws.CellCollection).SetValueAs(value);
+            }, col);
+        }, columns);
+        ws.RescanRows();
+        return ws;
+    }
+}

package/dist/ts/esm/ts/Spreadsheet/Metadata/Assays.js

@@ -0,0 +1,90 @@
+import { reverse, cons, iterateIndexed, empty, map as map_1, initialize, singleton, length, ofArray } from "@fable-org/fable-library-js/List.js";
+import { OntologyAnnotation } from "../../Core/OntologyAnnotation.js";
+import { defaultArg, map, value as value_1, unwrap } from "@fable-org/fable-library-js/Option.js";
+import { Assay_fileNameFromIdentifier, removeMissingIdentifier, Assay_tryIdentifierFromFileName, createMissingIdentifier } from "../../Core/Helper/Identifier.js";
+import { ResizeArray_iter, Option_fromValueWithDefault } from "../../Core/Helper/Collections.js";
+import { JsonTypes_composeTechnologyPlatform, JsonTypes_decomposeTechnologyPlatform } from "../../Core/Conversion.js";
+import { ArcAssay } from "../../Core/ArcTypes.js";
+import { SparseTable_ToRows_759CAFC1, SparseTable_FromRows_Z5579EC29, SparseTable_Create_Z2192E64B, SparseTable, SparseTable__TryGetValue_11FD62A8, SparseTable__TryGetValueDefault_5BAE6133, SparseTable_GetEmptyComments_3ECCA699 } from "./SparseTable.js";
+import { Comment_toString, Comment_fromString } from "./Comment.js";
+import { addToDict } from "@fable-org/fable-library-js/MapUtil.js";
+import { List_distinct } from "@fable-org/fable-library-js/Seq2.js";
+import { stringHash } from "@fable-org/fable-library-js/Util.js";
+export const labels = ofArray(["Identifier", "Title", "Description", "Measurement Type", "Measurement Type Term Accession Number", "Measurement Type Term Source REF", "Technology Type", "Technology Type Term Accession Number", "Technology Type Term Source REF", "Technology Platform", "File Name"]);
+export function fromString(identifier, title, description, measurementType, measurementTypeTermSourceREF, measurementTypeTermAccessionNumber, technologyType, technologyTypeTermSourceREF, technologyTypeTermAccessionNumber, technologyPlatform, fileName, comments) {
+    const measurementType_1 = OntologyAnnotation.create(unwrap(measurementType), unwrap(measurementTypeTermSourceREF), unwrap(measurementTypeTermAccessionNumber));
+    const technologyType_1 = OntologyAnnotation.create(unwrap(technologyType), unwrap(technologyTypeTermSourceREF), unwrap(technologyTypeTermAccessionNumber));
+    let identifier_4;
+    if (identifier == null) {
+        if (fileName == null) {
+            identifier_4 = createMissingIdentifier();
+        }
+        else {
+            const matchValue = Assay_tryIdentifierFromFileName(value_1(fileName));
+            identifier_4 = ((matchValue != null) ? value_1(matchValue) : createMissingIdentifier());
+        }
+    }
+    else {
+        identifier_4 = value_1(identifier);
+    }
+    const measurementType_2 = Option_fromValueWithDefault(new OntologyAnnotation(), measurementType_1);
+    const technologyType_2 = Option_fromValueWithDefault(new OntologyAnnotation(), technologyType_1);
+    const technologyPlatform_1 = map(JsonTypes_decomposeTechnologyPlatform, technologyPlatform);
+    return ArcAssay.make(identifier_4, title, description, measurementType_2, technologyType_2, technologyPlatform_1, [], undefined, [], comments);
+}
+export function fromSparseTable(matrix) {
+    if ((matrix.ColumnCount === 0) && (length(matrix.CommentKeys) !== 0)) {
+        const comments = SparseTable_GetEmptyComments_3ECCA699(matrix);
+        return singleton(ArcAssay.create(createMissingIdentifier(), undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, comments));
+    }
+    else {
+        return initialize(matrix.ColumnCount, (i) => {
+            let comments_1;
+            const collection = map_1((k) => Comment_fromString(k, SparseTable__TryGetValueDefault_5BAE6133(matrix, "", [k, i])), matrix.CommentKeys);
+            comments_1 = Array.from(collection);
+            return fromString(SparseTable__TryGetValue_11FD62A8(matrix, ["Identifier", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Title", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Description", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Measurement Type", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Measurement Type Term Source REF", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Measurement Type Term Accession Number", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Technology Type", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Technology Type Term Source REF", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Technology Type Term Accession Number", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["Technology Platform", i]), SparseTable__TryGetValue_11FD62A8(matrix, ["File Name", i]), comments_1);
+        });
+    }
+}
+export function toSparseTable(assays) {
+    const matrix = SparseTable_Create_Z2192E64B(undefined, labels, undefined, length(assays) + 1);
+    let commentKeys = empty();
+    iterateIndexed((i, a) => {
+        const processedFileName = a.Identifier.startsWith("MISSING_IDENTIFIER_") ? removeMissingIdentifier(a.Identifier) : Assay_fileNameFromIdentifier(a.Identifier);
+        const i_1 = (i + 1) | 0;
+        let mt_1;
+        const mt = defaultArg(a.MeasurementType, new OntologyAnnotation());
+        mt_1 = OntologyAnnotation.toStringObject(mt, true);
+        let tt_1;
+        const tt = defaultArg(a.TechnologyType, new OntologyAnnotation());
+        tt_1 = OntologyAnnotation.toStringObject(tt, true);
+        addToDict(matrix.Matrix, ["Identifier", i_1], removeMissingIdentifier(a.Identifier));
+        addToDict(matrix.Matrix, ["Title", i_1], defaultArg(a.Title, ""));
+        addToDict(matrix.Matrix, ["Description", i_1], defaultArg(a.Description, ""));
+        addToDict(matrix.Matrix, ["Measurement Type", i_1], mt_1.TermName);
+        addToDict(matrix.Matrix, ["Measurement Type Term Accession Number", i_1], mt_1.TermAccessionNumber);
+        addToDict(matrix.Matrix, ["Measurement Type Term Source REF", i_1], mt_1.TermSourceREF);
+        addToDict(matrix.Matrix, ["Technology Type", i_1], tt_1.TermName);
+        addToDict(matrix.Matrix, ["Technology Type Term Accession Number", i_1], tt_1.TermAccessionNumber);
+        addToDict(matrix.Matrix, ["Technology Type Term Source REF", i_1], tt_1.TermSourceREF);
+        addToDict(matrix.Matrix, ["Technology Platform", i_1], defaultArg(map(JsonTypes_composeTechnologyPlatform, a.TechnologyPlatform), ""));
+        addToDict(matrix.Matrix, ["File Name", i_1], processedFileName);
+        ResizeArray_iter((comment) => {
+            const patternInput = Comment_toString(comment);
+            const n = patternInput[0];
+            commentKeys = cons(n, commentKeys);
+            addToDict(matrix.Matrix, [n, i_1], patternInput[1]);
+        }, a.Comments);
+    }, assays);
+    return new SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(commentKeys, {
+        Equals: (x, y) => (x === y),
+        GetHashCode: stringHash,
+    })), matrix.ColumnCount);
+}
+export function fromRows(prefix, lineNumber, rows) {
+    const tupledArg = SparseTable_FromRows_Z5579EC29(rows, labels, lineNumber, unwrap(prefix));
+    return [tupledArg[0], tupledArg[1], tupledArg[2], fromSparseTable(tupledArg[3])];
+}
+export function toRows(prefix, assays) {
+    return SparseTable_ToRows_759CAFC1(toSparseTable(assays), unwrap(prefix));
+}