@nfdi4plants/arctrl 1.0.0-alpha10

package/ISA/ISA/ArcTypes/ArcTables.js

@@ -0,0 +1,479 @@
+import { append, toArray, reduce, choose, map as map_1, delay, toList, length, findIndex, tryFindIndex } from "../../../fable_modules/fable-library.4.1.4/Seq.js";
+import { Dict_tryFind } from "../Helper.js";
+import { addToSet, addToDict } from "../../../fable_modules/fable-library.4.1.4/MapUtil.js";
+import { equals, comparePrimitives, stringHash, compare, disposeSafe, getEnumerator } from "../../../fable_modules/fable-library.4.1.4/Util.js";
+import { bind, map as map_3, unwrap, defaultArg, value as value_2 } from "../../../fable_modules/fable-library.4.1.4/Option.js";
+import { collect as collect_1, map as map_4, insertRangeInPlace, fold } from "../../../fable_modules/fable-library.4.1.4/Array.js";
+import { CompositeHeader } from "./CompositeHeader.js";
+import { Array_groupBy, distinct } from "../../../fable_modules/fable-library.4.1.4/Seq2.js";
+import { FSharpSet__get_IsEmpty, ofSeq, intersect } from "../../../fable_modules/fable-library.4.1.4/Set.js";
+import { class_type } from "../../../fable_modules/fable-library.4.1.4/Reflection.js";
+import { ArcTable } from "./ArcTable.js";
+import { map as map_2, collect } from "../../../fable_modules/fable-library.4.1.4/List.js";
+import { Unchecked_fillMissingCells, ProcessParsing_groupProcesses, ProcessParsing_processToRows, ProcessParsing_alignByHeaders } from "./ArcTableAux.js";
+import { tryFind, ofSeq as ofSeq_1 } from "../../../fable_modules/fable-library.4.1.4/Map.js";
+
+/**
+ * If a table with the given name exists in the TableList, returns it, else returns None.
+ */
+export function ArcTablesAux_tryFindIndexByTableName(name, tables) {
+    return tryFindIndex((t) => (t.Name === name), tables);
+}
+
+/**
+ * If a table with the given name exists in the TableList, returns it, else fails.
+ */
+export function ArcTablesAux_findIndexByTableName(name, tables) {
+    const matchValue = tryFindIndex((t) => (t.Name === name), tables);
+    if (matchValue == null) {
+        throw new Error(`Unable to find table with name '${name}'!`);
+    }
+    else {
+        return matchValue | 0;
+    }
+}
+
+/**
+ * Collects the IOType of each distinct entity in the tables. Then merges the IOType of each entity according to the IOType.Merge function.
+ */
+export function ArcTablesAux_getIOMap(tables) {
+    const mappings = new Map([]);
+    const includeInMap = (name, ioType) => {
+        if (name !== "") {
+            const matchValue = Dict_tryFind(name, mappings);
+            if (matchValue == null) {
+                addToDict(mappings, name, ioType);
+            }
+            else {
+                const oldIOType = matchValue;
+                const newIOType = oldIOType.Merge(ioType);
+                mappings.set(name, newIOType);
+            }
+        }
+    };
+    let enumerator = getEnumerator(tables);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const table = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const matchValue_1 = table.TryGetInputColumn();
+            if (matchValue_1 == null) {
+            }
+            else {
+                const ic = matchValue_1;
+                const ioType_1 = value_2(ic.Header.tryInput());
+                ic.Cells.forEach((c) => {
+                    includeInMap(c.ToFreeTextCell().AsFreeText, ioType_1);
+                });
+            }
+            const matchValue_2 = table.TryGetOutputColumn();
+            if (matchValue_2 == null) {
+            }
+            else {
+                const oc = matchValue_2;
+                const ioType_2 = value_2(oc.Header.tryOutput());
+                oc.Cells.forEach((c_1) => {
+                    includeInMap(c_1.ToFreeTextCell().AsFreeText, ioType_2);
+                });
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return mappings;
+}
+
+export function ArcTablesAux_applyIOMap(map, tables) {
+    let enumerator = getEnumerator(tables);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const table = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const matchValue = table.TryGetInputColumn();
+            if (matchValue == null) {
+            }
+            else {
+                const ic = matchValue;
+                const index = findIndex((x) => x.isInput, table.Headers) | 0;
+                const newIOType = fold((io, c) => {
+                    const matchValue_1 = Dict_tryFind(c.ToFreeTextCell().AsFreeText, map);
+                    if (matchValue_1 == null) {
+                        return io;
+                    }
+                    else {
+                        const newIO = matchValue_1;
+                        return io.Merge(newIO);
+                    }
+                }, value_2(ic.Header.tryInput()), ic.Cells);
+                table.UpdateHeader(index, new CompositeHeader(11, [newIOType]));
+            }
+            const matchValue_2 = table.TryGetOutputColumn();
+            if (matchValue_2 == null) {
+            }
+            else {
+                const oc = matchValue_2;
+                const index_1 = findIndex((x_1) => x_1.isOutput, table.Headers) | 0;
+                const newIOType_1 = fold((io_1, c_1) => {
+                    const matchValue_3 = Dict_tryFind(c_1.ToFreeTextCell().AsFreeText, map);
+                    if (matchValue_3 == null) {
+                        return io_1;
+                    }
+                    else {
+                        const newIO_1 = matchValue_3;
+                        return io_1.Merge(newIO_1);
+                    }
+                }, value_2(oc.Header.tryOutput()), oc.Cells);
+                table.UpdateHeader(index_1, new CompositeHeader(12, [newIOType_1]));
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+
+/**
+ * Fails, if the index is out of range of the Tables collection. When allowAppend is set to true, it may be out of range by at most 1.
+ */
+export function ArcTablesAux_SanityChecks_validateSheetIndex(index, allowAppend, sheets) {
+    let x, y;
+    if (index < 0) {
+        throw new Error("Cannot insert ArcTable at index < 0.");
+    }
+    if ((x = (index | 0), (y = (sheets.length | 0), allowAppend ? (compare(x, y) > 0) : (compare(x, y) >= 0)))) {
+        throw new Error(`Specified index is out of range! Assay contains only ${sheets.length} tables.`);
+    }
+}
+
+/**
+ * Fails, if two tables have the same name.
+ */
+export function ArcTablesAux_SanityChecks_validateNamesUnique(names) {
+    if (!(length(names) === length(distinct(names, {
+        Equals: (x, y) => (x === y),
+        GetHashCode: stringHash,
+    })))) {
+        throw new Error("Cannot add multiple tables with the same name! Table names inside one assay must be unqiue");
+    }
+}
+
+/**
+ * Fails, if the name is already used by another table.
+ */
+export function ArcTablesAux_SanityChecks_validateNewNameUnique(newName, existingNames) {
+    const matchValue = tryFindIndex((x) => (x === newName), existingNames);
+    if (matchValue == null) {
+    }
+    else {
+        throw new Error(`Cannot create table with name ${newName}, as table names must be unique and table at index ${matchValue} has the same name.`);
+    }
+}
+
+/**
+ * Fails, if the name is already used by another table at a different position.
+ * 
+ * Does not fail, if the newName is the same as the one in the given position.
+ */
+export function ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, newName, existingNames) {
+    const matchValue = tryFindIndex((x) => (x === newName), existingNames);
+    if (matchValue == null) {
+    }
+    else if (index === matchValue) {
+        const i_1 = matchValue | 0;
+    }
+    else {
+        const i_2 = matchValue | 0;
+        throw new Error(`Cannot create table with name ${newName}, as table names must be unique and table at index ${i_2} has the same name.`);
+    }
+}
+
+export function ArcTablesAux_SanityChecks_validateNewNamesUnique(newNames, existingNames) {
+    ArcTablesAux_SanityChecks_validateNamesUnique(newNames);
+    const same = intersect(ofSeq(newNames, {
+        Compare: comparePrimitives,
+    }), ofSeq(existingNames, {
+        Compare: comparePrimitives,
+    }));
+    if (!FSharpSet__get_IsEmpty(same)) {
+        throw new Error(`Cannot create tables with the names ${same}, as table names must be unique.`);
+    }
+}
+
+export class ArcTables {
+    constructor(thisTables) {
+        this.thisTables = thisTables;
+    }
+}
+
+export function ArcTables_$reflection() {
+    return class_type("ARCtrl.ISA.ArcTables", void 0, ArcTables);
+}
+
+export function ArcTables_$ctor_Z18C2F36D(thisTables) {
+    return new ArcTables(thisTables);
+}
+
+export function ArcTables__get_Count(this$) {
+    return this$.thisTables.length;
+}
+
+export function ArcTables__get_TableNames(this$) {
+    return toList(delay(() => map_1((s) => s.Name, this$.thisTables)));
+}
+
+export function ArcTables__get_Tables(this$) {
+    return this$.thisTables;
+}
+
+export function ArcTables__get_Item_Z524259A4(this$, index) {
+    return this$.thisTables[index];
+}
+
+export function ArcTables__AddTable_EC12B15(this$, table, index) {
+    const index_1 = defaultArg(index, ArcTables__get_Count(this$)) | 0;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.thisTables);
+    ArcTablesAux_SanityChecks_validateNewNameUnique(table.Name, ArcTables__get_TableNames(this$));
+    this$.thisTables.splice(index_1, 0, table);
+}
+
+export function ArcTables__AddTables_Z2D453886(this$, tables, index) {
+    const index_1 = defaultArg(index, ArcTables__get_Count(this$)) | 0;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.thisTables);
+    ArcTablesAux_SanityChecks_validateNewNamesUnique(map_1((x) => x.Name, tables), ArcTables__get_TableNames(this$));
+    insertRangeInPlace(index_1, tables, this$.thisTables);
+}
+
+export function ArcTables__InitTable_3B406CA4(this$, tableName, index) {
+    const index_1 = defaultArg(index, ArcTables__get_Count(this$)) | 0;
+    const table = ArcTable.init(tableName);
+    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.thisTables);
+    ArcTablesAux_SanityChecks_validateNewNameUnique(table.Name, ArcTables__get_TableNames(this$));
+    this$.thisTables.splice(index_1, 0, table);
+    return table;
+}
+
+export function ArcTables__InitTables_7B28792B(this$, tableNames, index) {
+    const index_1 = defaultArg(index, ArcTables__get_Count(this$)) | 0;
+    const tables = map_1((x) => ArcTable.init(x), tableNames);
+    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.thisTables);
+    ArcTablesAux_SanityChecks_validateNewNamesUnique(map_1((x_1) => x_1.Name, tables), ArcTables__get_TableNames(this$));
+    insertRangeInPlace(index_1, tables, this$.thisTables);
+}
+
+export function ArcTables__GetTableAt_Z524259A4(this$, index) {
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
+    return this$.thisTables[index];
+}
+
+export function ArcTables__GetTable_Z721C83C5(this$, name) {
+    return ArcTables__GetTableAt_Z524259A4(this$, ArcTablesAux_findIndexByTableName(name, this$.thisTables));
+}
+
+export function ArcTables__UpdateTableAt_7E571736(this$, index, table) {
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
+    ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, table.Name, ArcTables__get_TableNames(this$));
+    this$.thisTables[index] = table;
+}
+
+export function ArcTables__UpdateTable_51766571(this$, name, table) {
+    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.thisTables), table];
+    ArcTables__UpdateTableAt_7E571736(this$, tupledArg[0], tupledArg[1]);
+}
+
+export function ArcTables__SetTableAt_7E571736(this$, index, table) {
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, true, this$.thisTables);
+    ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, table.Name, ArcTables__get_TableNames(this$));
+    this$.thisTables[index] = table;
+}
+
+export function ArcTables__SetTable_51766571(this$, name, table) {
+    const matchValue = ArcTablesAux_tryFindIndexByTableName(name, this$.thisTables);
+    if (matchValue == null) {
+        ArcTables__AddTable_EC12B15(this$, table);
+    }
+    else {
+        ArcTables__SetTableAt_7E571736(this$, matchValue, table);
+    }
+}
+
+export function ArcTables__RemoveTableAt_Z524259A4(this$, index) {
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
+    this$.thisTables.splice(index, 1);
+}
+
+export function ArcTables__RemoveTable_Z721C83C5(this$, name) {
+    ArcTables__RemoveTableAt_Z524259A4(this$, ArcTablesAux_findIndexByTableName(name, this$.thisTables));
+}
+
+export function ArcTables__MapTableAt_8FC095C(this$, index, updateFun) {
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
+    updateFun(this$.thisTables[index]);
+}
+
+export function ArcTables__MapTable_27DD7B1B(this$, name, updateFun) {
+    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.thisTables), updateFun];
+    ArcTables__MapTableAt_8FC095C(this$, tupledArg[0], tupledArg[1]);
+}
+
+export function ArcTables__RenameTableAt_Z176EF219(this$, index, newName) {
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.thisTables);
+    ArcTablesAux_SanityChecks_validateNewNameUnique(newName, ArcTables__get_TableNames(this$));
+    const table = ArcTables__GetTableAt_Z524259A4(this$, index);
+    table.Name = newName;
+}
+
+export function ArcTables__RenameTable_Z384F8060(this$, name, newName) {
+    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.thisTables), newName];
+    ArcTables__RenameTableAt_Z176EF219(this$, tupledArg[0], tupledArg[1]);
+}
+
+export function ArcTables__AddColumnAt_6A9784DB(this$, tableIndex, header, cells, columnIndex, forceReplace) {
+    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
+        table.AddColumn(header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+    });
+}
+
+export function ArcTables__AddColumn_1FF50D3C(this$, tableName, header, cells, columnIndex, forceReplace) {
+    ArcTables__AddColumnAt_6A9784DB(this$, ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+}
+
+export function ArcTables__RemoveColumnAt_Z37302880(this$, tableIndex, columnIndex) {
+    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
+        table.RemoveColumn(columnIndex);
+    });
+}
+
+export function ArcTables__RemoveColumn_Z18115A39(this$, tableName, columnIndex) {
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), columnIndex];
+    ArcTables__RemoveColumnAt_Z37302880(this$, tupledArg[0], tupledArg[1]);
+}
+
+export function ArcTables__UpdateColumnAt_21300791(this$, tableIndex, columnIndex, header, cells) {
+    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
+        table.UpdateColumn(columnIndex, header, unwrap(cells));
+    });
+}
+
+export function ArcTables__UpdateColumn_Z6083042A(this$, tableName, columnIndex, header, cells) {
+    ArcTables__UpdateColumnAt_21300791(this$, ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), columnIndex, header, unwrap(cells));
+}
+
+export function ArcTables__GetColumnAt_Z37302880(this$, tableIndex, columnIndex) {
+    const table = ArcTables__GetTableAt_Z524259A4(this$, tableIndex);
+    return table.GetColumn(columnIndex);
+}
+
+export function ArcTables__GetColumn_Z18115A39(this$, tableName, columnIndex) {
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), columnIndex];
+    return ArcTables__GetColumnAt_Z37302880(this$, tupledArg[0], tupledArg[1]);
+}
+
+export function ArcTables__AddRowAt_Z12CDB784(this$, tableIndex, cells, rowIndex) {
+    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
+        table.AddRow(unwrap(cells), unwrap(rowIndex));
+    });
+}
+
+export function ArcTables__AddRow_Z16315DE5(this$, tableName, cells, rowIndex) {
+    ArcTables__AddRowAt_Z12CDB784(this$, ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), unwrap(cells), unwrap(rowIndex));
+}
+
+export function ArcTables__RemoveRowAt_Z37302880(this$, tableIndex, rowIndex) {
+    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
+        table.RemoveRow(rowIndex);
+    });
+}
+
+export function ArcTables__RemoveRow_Z18115A39(this$, tableName, rowIndex) {
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), rowIndex];
+    ArcTables__RemoveRowAt_Z37302880(this$, tupledArg[0], tupledArg[1]);
+}
+
+export function ArcTables__UpdateRowAt_1CF7B5DC(this$, tableIndex, rowIndex, cells) {
+    ArcTables__MapTableAt_8FC095C(this$, tableIndex, (table) => {
+        table.UpdateRow(rowIndex, cells);
+    });
+}
+
+export function ArcTables__UpdateRow_1BFE2CFB(this$, tableName, rowIndex, cells) {
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), rowIndex, cells];
+    ArcTables__UpdateRowAt_1CF7B5DC(this$, tupledArg[0], tupledArg[1], tupledArg[2]);
+}
+
+export function ArcTables__GetRowAt_Z37302880(this$, tableIndex, rowIndex) {
+    const table = ArcTables__GetTableAt_Z524259A4(this$, tableIndex);
+    return table.GetRow(rowIndex);
+}
+
+export function ArcTables__GetRow_Z18115A39(this$, tableName, rowIndex) {
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.thisTables), rowIndex];
+    return ArcTables__GetRowAt_Z37302880(this$, tupledArg[0], tupledArg[1]);
+}
+
+/**
+ * Return a list of all the processes in all the tables.
+ */
+export function ArcTables__GetProcesses(this$) {
+    return collect((t) => t.GetProcesses(), toList(ArcTables__get_Tables(this$)));
+}
+
+export function ArcTables_ofSeq_3B4333A5(tables) {
+    return ArcTables_$ctor_Z18C2F36D(Array.from(tables));
+}
+
+/**
+ * Create a collection of tables from a list of processes.
+ * 
+ * For this, the processes are grouped by nameroot ("nameroot_1", "nameroot_2" ...) or exectued protocol if no name exists
+ * 
+ * Then each group is converted to a table with this nameroot as sheetname
+ */
+export function ArcTables_fromProcesses_134EBDED(ps) {
+    let arg;
+    return ArcTables_$ctor_Z18C2F36D((arg = map_2((tupledArg) => {
+        const tupledArg_1 = ProcessParsing_alignByHeaders(true, collect(ProcessParsing_processToRows, tupledArg[1]));
+        return ArcTable.create(tupledArg[0], tupledArg_1[0], tupledArg_1[1]);
+    }, ProcessParsing_groupProcesses(ps)), Array.from(arg)));
+}
+
+export function ArcTables_updateReferenceTablesBySheets_Z2EE88E97(referenceTables, sheetTables, keepUnusedRefTables) {
+    let arg_4, s, array;
+    const keepUnusedRefTables_1 = defaultArg(keepUnusedRefTables, false);
+    const usedTables = new Set([]);
+    const referenceTableMap = ofSeq_1(choose((t) => map_3((c) => [c.Cells[0].AsFreeText, t], t.TryGetProtocolNameColumn()), ArcTables__get_Tables(referenceTables)), {
+        Compare: comparePrimitives,
+    });
+    return ArcTables_$ctor_Z18C2F36D((arg_4 = ((s = map_4((t_3) => {
+        Unchecked_fillMissingCells(t_3.Headers, t_3.Values);
+        return t_3;
+    }, map_4((tupledArg) => reduce((arg_2, arg_3) => ArcTable.append(arg_2, arg_3), tupledArg[1]), Array_groupBy((t_2) => t_2.Name, map_4((t_1) => {
+        const k = defaultArg(bind((c_1) => {
+            if (c_1.AsFreeText === "") {
+                return void 0;
+            }
+            else {
+                return c_1.AsFreeText;
+            }
+        }, bind((i) => t_1.TryGetCellAt(i, 0), tryFindIndex((x_1) => equals(x_1, new CompositeHeader(8, [])), t_1.Headers))), t_1.Name);
+        const matchValue = tryFind(k, referenceTableMap);
+        if (matchValue == null) {
+            return t_1;
+        }
+        else {
+            const rt = matchValue;
+            addToSet(k, usedTables);
+            const updatedTable = ArcTable.updateReferenceByAnnotationTable(rt, t_1);
+            return ArcTable.create(t_1.Name, updatedTable.Headers, updatedTable.Values);
+        }
+    }, (array = toArray(ArcTables__get_Tables(sheetTables)), collect_1(ArcTable.SplitByProtocolREF, array))), {
+        Equals: (x_2, y_1) => (x_2 === y_1),
+        GetHashCode: stringHash,
+    }))), keepUnusedRefTables_1 ? append(choose((kv) => {
+        if (usedTables.has(kv[0])) {
+            return void 0;
+        }
+        else {
+            return kv[1];
+        }
+    }, referenceTableMap), s) : s)), Array.from(arg_4)));
+}
+