@nfdi4plants/arctrl 1.0.0-alpha10

package/ISA/ISA.Spreadsheet/ArcInvestigation.js

@@ -0,0 +1,314 @@
+import { Record } from "../../fable_modules/fable-library.4.1.4/Types.js";
+import { record_type, list_type, string_type } from "../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { Remark, Comment$_$reflection } from "../ISA/JsonTypes/Comment.js";
+import { ofSeq, head, tail, isEmpty, concat, unzip, append, toArray, reverse, cons, empty, map, ofArray } from "../../fable_modules/fable-library.4.1.4/List.js";
+import { Remark_wrapRemark, Comment_toString, Comment_fromString } from "./Metadata/Comment.js";
+import { SparseRowModule_writeToSheet, SparseRowModule_fromFsRow, SparseRowModule_fromValues, SparseRowModule_tryGetValueAt, SparseTable_ToRows_6A3D4534, SparseTable_FromRows_Z5579EC29, SparseTable, SparseTable_Create_Z2192E64B, SparseTable__TryGetValueDefault_5BAE6133 } from "./Metadata/SparseTable.js";
+import { addToDict } from "../../fable_modules/fable-library.4.1.4/MapUtil.js";
+import { value as value_1, defaultArg } from "../../fable_modules/fable-library.4.1.4/Option.js";
+import { List_distinctBy, List_distinct } from "../../fable_modules/fable-library.4.1.4/Seq2.js";
+import { comparePrimitives, getEnumerator, stringHash } from "../../fable_modules/fable-library.4.1.4/Util.js";
+import { Option_fromValueWithDefault } from "./Metadata/Conversions.js";
+import { ArcInvestigation } from "../ISA/ArcTypes/ArcTypes.js";
+import { toRows as toRows_1, fromRows as fromRows_1 } from "./Metadata/OntologySourceReference.js";
+import { toRows as toRows_2, fromRows as fromRows_2 } from "./Metadata/Publication.js";
+import { toRows as toRows_3, fromRows as fromRows_3 } from "./Metadata/Contacts.js";
+import { toRows as toRows_4, fromRows as fromRows_4 } from "./Metadata/Study.js";
+import { iterateIndexed, map as map_1, toList, collect, singleton, append as append_1, delay } from "../../fable_modules/fable-library.4.1.4/Seq.js";
+import { tryFind, ofList } from "../../fable_modules/fable-library.4.1.4/Map.js";
+import { printf, toFail } from "../../fable_modules/fable-library.4.1.4/String.js";
+import { FsWorksheet } from "../../fable_modules/FsSpreadsheet.4.1.0/FsWorksheet.fs.js";
+import { FsWorkbook } from "../../fable_modules/FsSpreadsheet.4.1.0/FsWorkbook.fs.js";
+
+export class InvestigationInfo extends Record {
+    constructor(Identifier, Title, Description, SubmissionDate, PublicReleaseDate, Comments) {
+        super();
+        this.Identifier = Identifier;
+        this.Title = Title;
+        this.Description = Description;
+        this.SubmissionDate = SubmissionDate;
+        this.PublicReleaseDate = PublicReleaseDate;
+        this.Comments = Comments;
+    }
+}
+
+export function InvestigationInfo_$reflection() {
+    return record_type("ARCtrl.ISA.Spreadsheet.ArcInvestigation.InvestigationInfo", [], InvestigationInfo, () => [["Identifier", string_type], ["Title", string_type], ["Description", string_type], ["SubmissionDate", string_type], ["PublicReleaseDate", string_type], ["Comments", list_type(Comment$_$reflection())]]);
+}
+
+export function InvestigationInfo_create(identifier, title, description, submissionDate, publicReleaseDate, comments) {
+    return new InvestigationInfo(identifier, title, description, submissionDate, publicReleaseDate, comments);
+}
+
+export function InvestigationInfo_get_Labels() {
+    return ofArray(["Investigation Identifier", "Investigation Title", "Investigation Description", "Investigation Submission Date", "Investigation Public Release Date"]);
+}
+
+export function InvestigationInfo_FromSparseTable_651559CC(matrix) {
+    const comments = map((k) => Comment_fromString(k, SparseTable__TryGetValueDefault_5BAE6133(matrix, "", [k, 0])), matrix.CommentKeys);
+    return InvestigationInfo_create(SparseTable__TryGetValueDefault_5BAE6133(matrix, "", ["Investigation Identifier", 0]), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", ["Investigation Title", 0]), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", ["Investigation Description", 0]), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", ["Investigation Submission Date", 0]), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", ["Investigation Public Release Date", 0]), comments);
+}
+
+export function InvestigationInfo_ToSparseTable_Z4D87C88C(investigation) {
+    const matrix = SparseTable_Create_Z2192E64B(void 0, InvestigationInfo_get_Labels(), void 0, 2);
+    let commentKeys = empty();
+    addToDict(matrix.Matrix, ["Investigation Identifier", 1], investigation.Identifier);
+    addToDict(matrix.Matrix, ["Investigation Title", 1], defaultArg(investigation.Title, ""));
+    addToDict(matrix.Matrix, ["Investigation Description", 1], defaultArg(investigation.Description, ""));
+    addToDict(matrix.Matrix, ["Investigation Submission Date", 1], defaultArg(investigation.SubmissionDate, ""));
+    addToDict(matrix.Matrix, ["Investigation Public Release Date", 1], defaultArg(investigation.PublicReleaseDate, ""));
+    if (!(investigation.Comments.length === 0)) {
+        const array = investigation.Comments;
+        array.forEach((comment) => {
+            const patternInput = Comment_toString(comment);
+            const n = patternInput[0];
+            commentKeys = cons(n, commentKeys);
+            addToDict(matrix.Matrix, [n, 1], patternInput[1]);
+        });
+    }
+    return new SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(commentKeys, {
+        Equals: (x, y) => (x === y),
+        GetHashCode: stringHash,
+    })), matrix.ColumnCount);
+}
+
+export function InvestigationInfo_fromRows(lineNumber, rows) {
+    const tupledArg = SparseTable_FromRows_Z5579EC29(rows, InvestigationInfo_get_Labels(), lineNumber);
+    return [tupledArg[0], tupledArg[1], tupledArg[2], InvestigationInfo_FromSparseTable_651559CC(tupledArg[3])];
+}
+
+export function InvestigationInfo_toRows_Z4D87C88C(investigation) {
+    return SparseTable_ToRows_6A3D4534(InvestigationInfo_ToSparseTable_Z4D87C88C(investigation));
+}
+
+export function fromParts(investigationInfo, ontologySourceReference, publications, contacts, studies, assays, remarks) {
+    const studyIdentifiers = map((s) => s.Identifier, studies);
+    const arg_1 = Option_fromValueWithDefault("", investigationInfo.Title);
+    const arg_2 = Option_fromValueWithDefault("", investigationInfo.Description);
+    const arg_3 = Option_fromValueWithDefault("", investigationInfo.SubmissionDate);
+    const arg_4 = Option_fromValueWithDefault("", investigationInfo.PublicReleaseDate);
+    const arg_5 = toArray(ontologySourceReference);
+    const arg_6 = toArray(publications);
+    const arg_7 = toArray(contacts);
+    const arg_8 = Array.from(assays);
+    const arg_9 = Array.from(studies);
+    const arg_10 = Array.from(studyIdentifiers);
+    const arg_11 = toArray(investigationInfo.Comments);
+    const arg_12 = toArray(remarks);
+    return ArcInvestigation.make(investigationInfo.Identifier, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6, arg_7, arg_8, arg_9, arg_10, arg_11, arg_12);
+}
+
+export function fromRows(rows) {
+    const en = getEnumerator(rows);
+    const emptyInvestigationInfo = InvestigationInfo_create("", "", "", "", "", empty());
+    const loop = (lastLine_mut, ontologySourceReferences_mut, investigationInfo_mut, publications_mut, contacts_mut, studies_mut, remarks_mut, lineNumber_mut) => {
+        loop:
+        while (true) {
+            const lastLine = lastLine_mut, ontologySourceReferences = ontologySourceReferences_mut, investigationInfo = investigationInfo_mut, publications = publications_mut, contacts = contacts_mut, studies = studies_mut, remarks = remarks_mut, lineNumber = lineNumber_mut;
+            let matchResult, k_5, k_6, k_7, k_8, k_9, k_10;
+            if (lastLine != null) {
+                switch (lastLine) {
+                    case "ONTOLOGY SOURCE REFERENCE": {
+                        matchResult = 0;
+                        k_5 = lastLine;
+                        break;
+                    }
+                    case "INVESTIGATION": {
+                        matchResult = 1;
+                        k_6 = lastLine;
+                        break;
+                    }
+                    case "INVESTIGATION PUBLICATIONS": {
+                        matchResult = 2;
+                        k_7 = lastLine;
+                        break;
+                    }
+                    case "INVESTIGATION CONTACTS": {
+                        matchResult = 3;
+                        k_8 = lastLine;
+                        break;
+                    }
+                    case "STUDY": {
+                        matchResult = 4;
+                        k_9 = lastLine;
+                        break;
+                    }
+                    default: {
+                        matchResult = 5;
+                        k_10 = lastLine;
+                    }
+                }
+            }
+            else {
+                matchResult = 5;
+                k_10 = lastLine;
+            }
+            switch (matchResult) {
+                case 0: {
+                    const patternInput = fromRows_1(lineNumber + 1, en);
+                    lastLine_mut = patternInput[0];
+                    ontologySourceReferences_mut = patternInput[3];
+                    investigationInfo_mut = investigationInfo;
+                    publications_mut = publications;
+                    contacts_mut = contacts;
+                    studies_mut = studies;
+                    remarks_mut = append(remarks, patternInput[2]);
+                    lineNumber_mut = patternInput[1];
+                    continue loop;
+                }
+                case 1: {
+                    const patternInput_1 = InvestigationInfo_fromRows(lineNumber + 1, en);
+                    lastLine_mut = patternInput_1[0];
+                    ontologySourceReferences_mut = ontologySourceReferences;
+                    investigationInfo_mut = patternInput_1[3];
+                    publications_mut = publications;
+                    contacts_mut = contacts;
+                    studies_mut = studies;
+                    remarks_mut = append(remarks, patternInput_1[2]);
+                    lineNumber_mut = patternInput_1[1];
+                    continue loop;
+                }
+                case 2: {
+                    const patternInput_2 = fromRows_2("Investigation Publication", lineNumber + 1, en);
+                    lastLine_mut = patternInput_2[0];
+                    ontologySourceReferences_mut = ontologySourceReferences;
+                    investigationInfo_mut = investigationInfo;
+                    publications_mut = patternInput_2[3];
+                    contacts_mut = contacts;
+                    studies_mut = studies;
+                    remarks_mut = append(remarks, patternInput_2[2]);
+                    lineNumber_mut = patternInput_2[1];
+                    continue loop;
+                }
+                case 3: {
+                    const patternInput_3 = fromRows_3("Investigation Person", lineNumber + 1, en);
+                    lastLine_mut = patternInput_3[0];
+                    ontologySourceReferences_mut = ontologySourceReferences;
+                    investigationInfo_mut = investigationInfo;
+                    publications_mut = publications;
+                    contacts_mut = patternInput_3[3];
+                    studies_mut = studies;
+                    remarks_mut = append(remarks, patternInput_3[2]);
+                    lineNumber_mut = patternInput_3[1];
+                    continue loop;
+                }
+                case 4: {
+                    const patternInput_4 = fromRows_4(lineNumber + 1, en);
+                    const study = patternInput_4[3];
+                    const newRemarks_4 = patternInput_4[2];
+                    const lineNumber_5 = patternInput_4[1] | 0;
+                    const currentLine_4 = patternInput_4[0];
+                    if (study != null) {
+                        lastLine_mut = currentLine_4;
+                        ontologySourceReferences_mut = ontologySourceReferences;
+                        investigationInfo_mut = investigationInfo;
+                        publications_mut = publications;
+                        contacts_mut = contacts;
+                        studies_mut = cons(value_1(study), studies);
+                        remarks_mut = append(remarks, newRemarks_4);
+                        lineNumber_mut = lineNumber_5;
+                        continue loop;
+                    }
+                    else {
+                        lastLine_mut = currentLine_4;
+                        ontologySourceReferences_mut = ontologySourceReferences;
+                        investigationInfo_mut = investigationInfo;
+                        publications_mut = publications;
+                        contacts_mut = contacts;
+                        studies_mut = studies;
+                        remarks_mut = append(remarks, newRemarks_4);
+                        lineNumber_mut = lineNumber_5;
+                        continue loop;
+                    }
+                }
+                default: {
+                    let patternInput_5;
+                    const tupledArg = unzip(studies);
+                    patternInput_5 = [reverse(tupledArg[0]), List_distinctBy((a_1) => a_1.Identifier, concat(tupledArg[1]), {
+                        Equals: (x, y) => (x === y),
+                        GetHashCode: stringHash,
+                    })];
+                    return fromParts(investigationInfo, ontologySourceReferences, publications, contacts, patternInput_5[0], patternInput_5[1], remarks);
+                }
+            }
+            break;
+        }
+    };
+    if (en["System.Collections.IEnumerator.MoveNext"]()) {
+        return loop(SparseRowModule_tryGetValueAt(0, en["System.Collections.Generic.IEnumerator`1.get_Current"]()), empty(), emptyInvestigationInfo, empty(), empty(), empty(), empty(), 1);
+    }
+    else {
+        throw new Error("emptyInvestigationFile");
+    }
+}
+
+export function toRows(investigation) {
+    let remarks, rows;
+    return (remarks = ofArray(investigation.Remarks), (rows = delay(() => append_1(singleton(SparseRowModule_fromValues(["ONTOLOGY SOURCE REFERENCE"])), delay(() => append_1(toRows_1(ofArray(investigation.OntologySourceReferences)), delay(() => append_1(singleton(SparseRowModule_fromValues(["INVESTIGATION"])), delay(() => append_1(InvestigationInfo_toRows_Z4D87C88C(investigation), delay(() => append_1(singleton(SparseRowModule_fromValues(["INVESTIGATION PUBLICATIONS"])), delay(() => append_1(toRows_2("Investigation Publication", ofArray(investigation.Publications)), delay(() => append_1(singleton(SparseRowModule_fromValues(["INVESTIGATION CONTACTS"])), delay(() => append_1(toRows_3("Investigation Person", ofArray(investigation.Contacts)), delay(() => collect((study) => append_1(singleton(SparseRowModule_fromValues(["STUDY"])), delay(() => toRows_4(study, void 0))), investigation.RegisteredStudies)))))))))))))))))), (() => {
+        try {
+            const rm = ofList(map((arg) => Remark.toTuple(arg), remarks), {
+                Compare: comparePrimitives,
+            });
+            const loop = (i_mut, l_mut, nl_mut) => {
+                loop:
+                while (true) {
+                    const i = i_mut, l = l_mut, nl = nl_mut;
+                    const matchValue = tryFind(i, rm);
+                    if (matchValue == null) {
+                        if (!isEmpty(l)) {
+                            i_mut = (i + 1);
+                            l_mut = tail(l);
+                            nl_mut = cons(head(l), nl);
+                            continue loop;
+                        }
+                        else {
+                            return nl;
+                        }
+                    }
+                    else {
+                        const remark = matchValue;
+                        i_mut = (i + 1);
+                        l_mut = l;
+                        nl_mut = cons(SparseRowModule_fromValues([Remark_wrapRemark(remark)]), nl);
+                        continue loop;
+                    }
+                    break;
+                }
+            };
+            return reverse(loop(1, ofSeq(rows), empty()));
+        }
+        catch (matchValue_1) {
+            return toList(rows);
+        }
+    })()));
+}
+
+export function fromFsWorkbook(doc) {
+    let arg, matchValue, matchValue_1;
+    try {
+        return fromRows(map_1(SparseRowModule_fromFsRow, (arg = ((matchValue = doc.TryGetWorksheetByName("isa_investigation"), (matchValue == null) ? ((matchValue_1 = doc.TryGetWorksheetByName("Investigation"), (matchValue_1 == null) ? (() => {
+            throw new Error("Could not find metadata sheet with sheetname \"isa_investigation\" or deprecated sheetname \"Investigation\"");
+        })() : matchValue_1)) : matchValue)), FsWorksheet.getRows(arg))));
+    }
+    catch (err) {
+        const arg_1 = err.message;
+        return toFail(printf("Could not read investigation from spreadsheet: %s"))(arg_1);
+    }
+}
+
+export function toFsWorkbook(investigation) {
+    try {
+        const wb = new FsWorkbook();
+        const sheet = new FsWorksheet("isa_investigation");
+        iterateIndexed((rowI, r) => {
+            SparseRowModule_writeToSheet(rowI + 1, r, sheet);
+        }, toRows(investigation));
+        wb.AddWorksheet(sheet);
+        return wb;
+    }
+    catch (err) {
+        const arg = err.message;
+        return toFail(printf("Could not write investigation to spreadsheet: %s"))(arg);
+    }
+}
+

package/ISA/ISA.Spreadsheet/ArcStudy.js

@@ -0,0 +1,67 @@
+import { FsWorksheet } from "../../fable_modules/FsSpreadsheet.4.1.0/FsWorksheet.fs.js";
+import { iterate, isEmpty, choose, map, append, iterateIndexed } from "../../fable_modules/fable-library.4.1.4/Seq.js";
+import { SparseRowModule_fromFsRow, SparseRowModule_fromValues, SparseRowModule_writeToSheet } from "./Metadata/SparseTable.js";
+import { fromRows as fromRows_1, toRows } from "./Metadata/Study.js";
+import { defaultArg } from "../../fable_modules/fable-library.4.1.4/Option.js";
+import { getEnumerator } from "../../fable_modules/fable-library.4.1.4/Util.js";
+import { ArcStudy } from "../ISA/ArcTypes/ArcTypes.js";
+import { createMissingIdentifier } from "../ISA/Identifier.js";
+import { empty } from "../../fable_modules/fable-library.4.1.4/List.js";
+import { printf, toConsole } from "../../fable_modules/fable-library.4.1.4/String.js";
+import { toFsWorksheet, tryFromFsWorksheet } from "./AnnotationTable/ArcTable.js";
+import { ArcTables__get_Tables, ArcTables_$ctor_Z18C2F36D, ArcTables_updateReferenceTablesBySheets_Z2EE88E97 } from "../ISA/ArcTypes/ArcTables.js";
+import { FsWorkbook } from "../../fable_modules/FsSpreadsheet.4.1.0/FsWorkbook.fs.js";
+
+export function ArcStudy_toMetadataSheet(study, assays) {
+    let source_1;
+    const sheet = new FsWorksheet("isa_study");
+    iterateIndexed((rowI, r) => {
+        SparseRowModule_writeToSheet(rowI + 1, r, sheet);
+    }, (source_1 = toRows(study, assays), append([SparseRowModule_fromValues(["STUDY"])], source_1)));
+    return sheet;
+}
+
+export function ArcStudy_fromMetadataSheet(sheet) {
+    let en;
+    return defaultArg((en = getEnumerator(map(SparseRowModule_fromFsRow, sheet.Rows)), (void en["System.Collections.IEnumerator.MoveNext"](), fromRows_1(2, en)[3])), [ArcStudy.create(createMissingIdentifier()), empty()]);
+}
+
+/**
+ * Reads an assay from a spreadsheet
+ */
+export function ARCtrl_ISA_ArcStudy__ArcStudy_fromFsWorkbook_Static_32154C9D(doc) {
+    let patternInput;
+    const matchValue = doc.TryGetWorksheetByName("isa_study");
+    if (matchValue == null) {
+        const matchValue_1 = doc.TryGetWorksheetByName("Study");
+        if (matchValue_1 == null) {
+            toConsole(printf("Cannot retrieve metadata: Study file does not contain \"%s\" or \"%s\" sheet."))("isa_study")("Study");
+            patternInput = [ArcStudy.create(createMissingIdentifier()), empty()];
+        }
+        else {
+            patternInput = ArcStudy_fromMetadataSheet(matchValue_1);
+        }
+    }
+    else {
+        patternInput = ArcStudy_fromMetadataSheet(matchValue);
+    }
+    const studyMetadata = patternInput[0];
+    const sheets = choose(tryFromFsWorksheet, doc.GetWorksheets());
+    if (!isEmpty(sheets)) {
+        const updatedTables = ArcTables_updateReferenceTablesBySheets_Z2EE88E97(ArcTables_$ctor_Z18C2F36D(studyMetadata.Tables), ArcTables_$ctor_Z18C2F36D(Array.from(sheets)), true);
+        studyMetadata.Tables = ArcTables__get_Tables(updatedTables);
+    }
+    return [studyMetadata, patternInput[1]];
+}
+
+export function ARCtrl_ISA_ArcStudy__ArcStudy_toFsWorkbook_Static_Z2A9662E9(study, assays) {
+    const doc = new FsWorkbook();
+    const metaDataSheet = ArcStudy_toMetadataSheet(study, assays);
+    doc.AddWorksheet(metaDataSheet);
+    iterate((arg_1) => {
+        const arg = toFsWorksheet(arg_1);
+        doc.AddWorksheet(arg);
+    }, study.Tables);
+    return doc;
+}
+

package/ISA/ISA.Spreadsheet/CollectionAux.js

@@ -0,0 +1,128 @@
+import { tryFind, maxBy, skip } from "../../fable_modules/fable-library.4.1.4/Seq.js";
+import { tryItem, skip as skip_1, initialize } from "../../fable_modules/fable-library.4.1.4/Array.js";
+import { defaultOf, comparePrimitives } from "../../fable_modules/fable-library.4.1.4/Util.js";
+import { some, value } from "../../fable_modules/fable-library.4.1.4/Option.js";
+import { empty, tail, cons, head, reverse, isEmpty, tryPick } from "../../fable_modules/fable-library.4.1.4/List.js";
+import { tryGetValue } from "../../fable_modules/fable-library.4.1.4/MapUtil.js";
+import { FSharpRef } from "../../fable_modules/fable-library.4.1.4/Types.js";
+
+/**
+ * If at least i values exist in seq a, builds a new array that contains the elements of the given seq, exluding the first i elements
+ */
+export function Seq_trySkip(i, s) {
+    try {
+        return skip(i, s);
+    }
+    catch (matchValue) {
+        return void 0;
+    }
+}
+
+export function Array_ofIndexedSeq(s) {
+    return initialize(1 + maxBy((tuple) => tuple[0], s, {
+        Compare: comparePrimitives,
+    })[0], (i) => {
+        const matchValue = tryFind((arg) => (i === arg[0]), s);
+        if (matchValue == null) {
+            return "";
+        }
+        else {
+            const i_1 = matchValue[0] | 0;
+            return matchValue[1];
+        }
+    });
+}
+
+/**
+ * If at least i values exist in array a, builds a new array that contains the elements of the given array, exluding the first i elements
+ */
+export function Array_trySkip(i, a) {
+    try {
+        return skip_1(i, a);
+    }
+    catch (matchValue) {
+        return void 0;
+    }
+}
+
+/**
+ * Returns Item of array at index i if existing, else returns default value
+ */
+export function Array_tryItemDefault(i, d, a) {
+    const matchValue = tryItem(i, a);
+    if (matchValue == null) {
+        return d;
+    }
+    else {
+        return value(matchValue);
+    }
+}
+
+export function Array_map4(f, aa, ba, ca, da) {
+    if (!(((aa.length === ba.length) && (ba.length === ca.length)) && (ca.length === da.length))) {
+        throw new Error("");
+    }
+    return initialize(aa.length, (i) => f(aa[i], ba[i], ca[i], da[i]));
+}
+
+export function List_tryPickDefault(chooser, d, list) {
+    const matchValue = tryPick(chooser, list);
+    if (matchValue == null) {
+        return d;
+    }
+    else {
+        return value(matchValue);
+    }
+}
+
+export function List_unzip4(l) {
+    const loop = (la_mut, lb_mut, lc_mut, ld_mut, l_1_mut) => {
+        loop:
+        while (true) {
+            const la = la_mut, lb = lb_mut, lc = lc_mut, ld = ld_mut, l_1 = l_1_mut;
+            if (isEmpty(l_1)) {
+                return [reverse(la), reverse(lb), reverse(lc), reverse(ld)];
+            }
+            else {
+                la_mut = cons(head(l_1)[0], la);
+                lb_mut = cons(head(l_1)[1], lb);
+                lc_mut = cons(head(l_1)[2], lc);
+                ld_mut = cons(head(l_1)[3], ld);
+                l_1_mut = tail(l_1);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(empty(), empty(), empty(), empty(), l);
+}
+
+export function Dictionary_tryGetValue(k, dict) {
+    let patternInput;
+    let outArg = defaultOf();
+    patternInput = [tryGetValue(dict, k, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+    })), outArg];
+    if (patternInput[0]) {
+        return some(patternInput[1]);
+    }
+    else {
+        return void 0;
+    }
+}
+
+export function Dictionary_tryGetString(k, dict) {
+    let patternInput;
+    let outArg = defaultOf();
+    patternInput = [tryGetValue(dict, k, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+    })), outArg];
+    const v_1 = patternInput[1];
+    if (patternInput[0] && (v_1.trim() !== "")) {
+        return v_1.trim();
+    }
+    else {
+        return void 0;
+    }
+}
+

package/ISA/ISA.Spreadsheet/Metadata/Assays.js

@@ -0,0 +1,81 @@
+import { reverse, cons, iterateIndexed, empty, map as map_1, toArray, initialize, singleton, length, ofArray } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { OntologyAnnotation } from "../../ISA/JsonTypes/OntologyAnnotation.js";
+import { Option_fromValueWithDefault } from "./Conversions.js";
+import { unwrap, defaultArg, map } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { ArcAssay } from "../../ISA/ArcTypes/ArcTypes.js";
+import { SparseTable_ToRows_6A3D4534, SparseTable_FromRows_Z5579EC29, SparseTable, SparseTable_Create_Z2192E64B, SparseTable__TryGetValue_11FD62A8, SparseTable__TryGetValueDefault_5BAE6133, SparseTable_GetEmptyComments_651559CC } from "./SparseTable.js";
+import { Assay_fileNameFromIdentifier, removeMissingIdentifier, Assay_identifierFromFileName, createMissingIdentifier } from "../../ISA/Identifier.js";
+import { Comment_toString, Comment_fromString } from "./Comment.js";
+import { addToDict } from "../../../fable_modules/fable-library.4.1.4/MapUtil.js";
+import { List_distinct } from "../../../fable_modules/fable-library.4.1.4/Seq2.js";
+import { stringHash } from "../../../fable_modules/fable-library.4.1.4/Util.js";
+
+export const labels = ofArray(["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(measurementType, measurementTypeTermSourceREF, measurementTypeTermAccessionNumber, technologyType, technologyTypeTermSourceREF, technologyTypeTermAccessionNumber, technologyPlatform, fileName, comments) {
+    const measurementType_1 = OntologyAnnotation.fromString(measurementType, measurementTypeTermSourceREF, measurementTypeTermAccessionNumber);
+    const technologyType_1 = OntologyAnnotation.fromString(technologyType, technologyTypeTermSourceREF, technologyTypeTermAccessionNumber);
+    const arg_1 = Option_fromValueWithDefault(OntologyAnnotation.empty, measurementType_1);
+    const arg_2 = Option_fromValueWithDefault(OntologyAnnotation.empty, technologyType_1);
+    const arg_3 = map((arg_7) => ArcAssay.decomposeTechnologyPlatform(arg_7), technologyPlatform);
+    return ArcAssay.make(fileName, arg_1, arg_2, arg_3, [], [], comments);
+}
+
+export function fromSparseTable(matrix) {
+    if ((matrix.ColumnCount === 0) && (length(matrix.CommentKeys) !== 0)) {
+        const comments = SparseTable_GetEmptyComments_651559CC(matrix);
+        return singleton(ArcAssay.create(createMissingIdentifier(), void 0, void 0, void 0, void 0, void 0, comments));
+    }
+    else {
+        return initialize(matrix.ColumnCount, (i) => {
+            const comments_1 = toArray(map_1((k) => Comment_fromString(k, SparseTable__TryGetValueDefault_5BAE6133(matrix, "", [k, i])), matrix.CommentKeys));
+            return fromString(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]), Assay_identifierFromFileName(SparseTable__TryGetValueDefault_5BAE6133(matrix, createMissingIdentifier(), ["File Name", i])), comments_1);
+        });
+    }
+}
+
+export function toSparseTable(assays) {
+    const matrix = SparseTable_Create_Z2192E64B(void 0, labels, void 0, length(assays) + 1);
+    let commentKeys = empty();
+    iterateIndexed((i, a) => {
+        const processedFileName = (a.Identifier.indexOf("MISSING_IDENTIFIER_") === 0) ? removeMissingIdentifier(a.Identifier) : Assay_fileNameFromIdentifier(a.Identifier);
+        const i_1 = (i + 1) | 0;
+        let mt_1;
+        const mt = defaultArg(a.MeasurementType, OntologyAnnotation.empty);
+        mt_1 = OntologyAnnotation.toString(mt, true);
+        let tt_1;
+        const tt = defaultArg(a.TechnologyType, OntologyAnnotation.empty);
+        tt_1 = OntologyAnnotation.toString(tt, true);
+        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((arg) => ArcAssay.composeTechnologyPlatform(arg), a.TechnologyPlatform), ""));
+        addToDict(matrix.Matrix, ["File Name", i_1], processedFileName);
+        if (!(a.Comments.length === 0)) {
+            const array = a.Comments;
+            array.forEach((comment) => {
+                const patternInput = Comment_toString(comment);
+                const n = patternInput[0];
+                commentKeys = cons(n, commentKeys);
+                addToDict(matrix.Matrix, [n, i_1], patternInput[1]);
+            });
+        }
+    }, 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_6A3D4534(toSparseTable(assays), unwrap(prefix));
+}
+

package/ISA/ISA.Spreadsheet/Metadata/Comment.js

@@ -0,0 +1,60 @@
+import { defaultArg, bind } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { match } from "../../../fable_modules/fable-library.4.1.4/RegExp.js";
+import { printf, toText } from "../../../fable_modules/fable-library.4.1.4/String.js";
+import { Option_fromValueWithDefault } from "./Conversions.js";
+import { Comment$ } from "../../ISA/JsonTypes/Comment.js";
+
+export const Comment_commentRegex = /(?<=Comment\[<).*(?=>\])/gu;
+
+export const Comment_commentRegexNoAngleBrackets = /(?<=Comment\[).*(?=\])/gu;
+
+export function Comment_$007CComment$007C_$007C(key) {
+    return bind((k) => {
+        const r = match(Comment_commentRegex, k);
+        if (r != null) {
+            return r[0];
+        }
+        else {
+            const r_1 = match(Comment_commentRegexNoAngleBrackets, k);
+            if (r_1 != null) {
+                return r_1[0];
+            }
+            else {
+                return void 0;
+            }
+        }
+    }, key);
+}
+
+export function Comment_wrapCommentKey(k) {
+    return toText(printf("Comment[%s]"))(k);
+}
+
+export function Comment_fromString(k, v) {
+    const arg_1 = Option_fromValueWithDefault("", k);
+    const arg_2 = Option_fromValueWithDefault("", v);
+    return Comment$.make(void 0, arg_1, arg_2);
+}
+
+export function Comment_toString(c) {
+    return [defaultArg(c.Name, ""), defaultArg(c.Value, "")];
+}
+
+export const Remark_remarkRegex = /(?<=#).*/gu;
+
+export function Remark_$007CRemark$007C_$007C(key) {
+    return bind((k) => {
+        const r = match(Remark_remarkRegex, k);
+        if (r != null) {
+            return r[0];
+        }
+        else {
+            return void 0;
+        }
+    }, key);
+}
+
+export function Remark_wrapRemark(r) {
+    return toText(printf("#%s"))(r);
+}
+