@nfdi4plants/arctrl 3.0.0-beta.3 → 3.0.0-beta.4

package/dist/ts/ts/Core/Table/ArcTables.js

@@ -0,0 +1,415 @@
+import { toList, delay, map, choose, append, tryFindIndex, reduce, length, findIndex } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { ArcTable } from './ArcTable.js';
+import { defaultArg, value, unwrap, map as map$1, bind } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { CompositeHeader_ProtocolREF, CompositeHeader_Input, CompositeHeader_Output } from './CompositeHeader.js';
+import { equals, getEnumerator, toIterator, compare, disposeSafe, stringHash, comparePrimitives } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { ResizeArray_map, ResizeArray_groupBy, ResizeArray_collect, ResizeArray_iter, ResizeArray_fold, Dictionary_tryFind } from '../Helper/Collections.js';
+import { addToSet, addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { distinct } from '../../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { intersect, ofSeq as ofSeq$1, FSharpSet__get_IsEmpty } from '../../../node_modules/@fable-org/fable-library-js/Set.js';
+import { insertRangeInPlace } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { ofSeq, tryFind } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+
+function ArcTablesAux_tryFindIndexByTableName(name, tables) {
+  return tryFindIndex((t) => t.Name === name, tables);
+}
+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 value(matchValue) | 0;
+  }
+}
+function ArcTablesAux_getIOMap(tables) {
+  const mappings = /* @__PURE__ */ new Map([]);
+  const includeInMap = (name, ioType) => {
+    if (name !== "") {
+      const matchValue = Dictionary_tryFind(name, mappings);
+      if (matchValue == null) {
+        addToDict(mappings, name, ioType);
+      } else {
+        const oldIOType = value(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 = value(matchValue_1);
+        const ioType_1 = value(ic.Header.TryInput());
+        ResizeArray_iter((c) => {
+          includeInMap(c.ToFreeTextCell().AsFreeText, ioType_1);
+        }, ic.Cells);
+      }
+      const matchValue_2 = table.TryGetOutputColumn();
+      if (matchValue_2 == null) {
+      } else {
+        const oc = value(matchValue_2);
+        const ioType_2 = value(oc.Header.TryOutput());
+        ResizeArray_iter((c_1) => {
+          includeInMap(c_1.ToFreeTextCell().AsFreeText, ioType_2);
+        }, oc.Cells);
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return mappings;
+}
+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 = value(matchValue);
+        const index = findIndex((x) => x.isInput, table.Headers) | 0;
+        const newIOType = ResizeArray_fold((io, c) => {
+          const matchValue_1 = Dictionary_tryFind(c.ToFreeTextCell().AsFreeText, map);
+          if (matchValue_1 == null) {
+            return io;
+          } else {
+            const newIO = value(matchValue_1);
+            return io.Merge(newIO);
+          }
+        }, value(ic.Header.TryInput()), ic.Cells);
+        table.UpdateHeader(index, CompositeHeader_Input(newIOType));
+      }
+      const matchValue_2 = table.TryGetOutputColumn();
+      if (matchValue_2 == null) {
+      } else {
+        const oc = value(matchValue_2);
+        const index_1 = findIndex((x_1) => x_1.isOutput, table.Headers) | 0;
+        const newIOType_1 = ResizeArray_fold((io_1, c_1) => {
+          const matchValue_3 = Dictionary_tryFind(c_1.ToFreeTextCell().AsFreeText, map);
+          if (matchValue_3 == null) {
+            return io_1;
+          } else {
+            const newIO_1 = value(matchValue_3);
+            return io_1.Merge(newIO_1);
+          }
+        }, value(oc.Header.TryOutput()), oc.Cells);
+        table.UpdateHeader(index_1, CompositeHeader_Output(newIOType_1));
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+}
+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.`);
+  }
+}
+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");
+  }
+}
+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 ${value(matchValue)} has the same name.`);
+  }
+}
+function ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, newName, existingNames) {
+  const matchValue = tryFindIndex((x) => x === newName, existingNames);
+  if (matchValue == null) ; else if (index === value(matchValue)) {
+    value(matchValue) | 0;
+  } else {
+    const i_2 = value(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.`);
+  }
+}
+function ArcTablesAux_SanityChecks_validateNewNamesUnique(newNames, existingNames) {
+  ArcTablesAux_SanityChecks_validateNamesUnique(newNames);
+  const same = intersect(ofSeq$1(newNames, {
+    Compare: comparePrimitives
+  }), ofSeq$1(existingNames, {
+    Compare: comparePrimitives
+  }));
+  if (!FSharpSet__get_IsEmpty(same)) {
+    throw new Error(`Cannot create tables with the names ${same}, as table names must be unique.`);
+  }
+}
+class ArcTables {
+  constructor(initTables) {
+    this.tables = (ArcTablesAux_SanityChecks_validateNamesUnique(map((t) => t.Name, initTables)), initTables);
+  }
+  get Tables() {
+    const this$ = this;
+    return this$.tables;
+  }
+  set Tables(newTables) {
+    const this$ = this;
+    this$.tables = newTables;
+  }
+  get_Item(index) {
+    const this$ = this;
+    return this$.Tables[index];
+  }
+  get TableNames() {
+    const this$ = this;
+    return toList(delay(() => map((s) => s.Name, this$.Tables)));
+  }
+  get TableCount() {
+    const this$ = this;
+    return this$.Tables.length | 0;
+  }
+  AddTable(table, index) {
+    const this$ = this;
+    const index_1 = defaultArg(index, this$.TableCount) | 0;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.Tables);
+    ArcTablesAux_SanityChecks_validateNewNameUnique(table.Name, this$.TableNames);
+    this$.Tables.splice(index_1, 0, table);
+  }
+  AddTables(tables, index) {
+    const this$ = this;
+    const index_1 = defaultArg(index, this$.TableCount) | 0;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.Tables);
+    ArcTablesAux_SanityChecks_validateNewNamesUnique(map((x) => x.Name, tables), this$.TableNames);
+    insertRangeInPlace(index_1, tables, this$.Tables);
+  }
+  InitTable(tableName, index) {
+    const this$ = this;
+    const index_1 = defaultArg(index, this$.TableCount) | 0;
+    const table = ArcTable.init(tableName);
+    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.Tables);
+    ArcTablesAux_SanityChecks_validateNewNameUnique(table.Name, this$.TableNames);
+    this$.Tables.splice(index_1, 0, table);
+    return table;
+  }
+  InitTables(tableNames, index) {
+    const this$ = this;
+    const index_1 = defaultArg(index, this$.TableCount) | 0;
+    const tables = map((x) => ArcTable.init(x), tableNames);
+    ArcTablesAux_SanityChecks_validateSheetIndex(index_1, true, this$.Tables);
+    ArcTablesAux_SanityChecks_validateNewNamesUnique(map((x_1) => x_1.Name, tables), this$.TableNames);
+    insertRangeInPlace(index_1, tables, this$.Tables);
+  }
+  GetTableAt(index) {
+    const this$ = this;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+    return this$.Tables[index];
+  }
+  GetTable(name) {
+    const this$ = this;
+    const index = ArcTablesAux_findIndexByTableName(name, this$.Tables) | 0;
+    return this$.GetTableAt(index);
+  }
+  UpdateTableAt(index, table) {
+    const this$ = this;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+    ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, table.Name, this$.TableNames);
+    this$.Tables[index] = table;
+  }
+  UpdateTable(name, table) {
+    const this$ = this;
+    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.Tables), table];
+    this$.UpdateTableAt(tupledArg[0], tupledArg[1]);
+  }
+  SetTableAt(index, table) {
+    const this$ = this;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, true, this$.Tables);
+    ArcTablesAux_SanityChecks_validateNewNameAtUnique(index, table.Name, this$.TableNames);
+    this$.Tables[index] = table;
+  }
+  SetTable(name, table) {
+    const this$ = this;
+    const matchValue = ArcTablesAux_tryFindIndexByTableName(name, this$.Tables);
+    if (matchValue == null) {
+      this$.AddTable(table);
+    } else {
+      const index = value(matchValue) | 0;
+      this$.SetTableAt(index, table);
+    }
+  }
+  RemoveTableAt(index) {
+    const this$ = this;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+    this$.Tables.splice(index, 1);
+  }
+  RemoveTable(name) {
+    const this$ = this;
+    const index = ArcTablesAux_findIndexByTableName(name, this$.Tables) | 0;
+    this$.RemoveTableAt(index);
+  }
+  MapTableAt(index, updateFun) {
+    const this$ = this;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+    updateFun(this$.Tables[index]);
+  }
+  MapTable(name, updateFun) {
+    const this$ = this;
+    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.Tables), updateFun];
+    this$.MapTableAt(tupledArg[0], tupledArg[1]);
+  }
+  RenameTableAt(index, newName) {
+    const this$ = this;
+    ArcTablesAux_SanityChecks_validateSheetIndex(index, false, this$.Tables);
+    ArcTablesAux_SanityChecks_validateNewNameUnique(newName, this$.TableNames);
+    const table = this$.GetTableAt(index);
+    table.Name = newName;
+  }
+  RenameTable(name, newName) {
+    const this$ = this;
+    const tupledArg = [ArcTablesAux_findIndexByTableName(name, this$.Tables), newName];
+    this$.RenameTableAt(tupledArg[0], tupledArg[1]);
+  }
+  AddColumnAt(tableIndex, header, cells, columnIndex, forceReplace) {
+    const this$ = this;
+    this$.MapTableAt(tableIndex, (table) => {
+      table.AddColumn(header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+    });
+  }
+  AddColumn(tableName, header, cells, columnIndex, forceReplace) {
+    const this$ = this;
+    const i = ArcTablesAux_findIndexByTableName(tableName, this$.Tables) | 0;
+    this$.AddColumnAt(i, header, unwrap(cells), unwrap(columnIndex), unwrap(forceReplace));
+  }
+  RemoveColumnAt(tableIndex, columnIndex) {
+    const this$ = this;
+    this$.MapTableAt(tableIndex, (table) => {
+      table.RemoveColumn(columnIndex);
+    });
+  }
+  RemoveColumn(tableName, columnIndex) {
+    const this$ = this;
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), columnIndex];
+    this$.RemoveColumnAt(tupledArg[0], tupledArg[1]);
+  }
+  UpdateColumnAt(tableIndex, columnIndex, header, cells) {
+    const this$ = this;
+    this$.MapTableAt(tableIndex, (table) => {
+      table.UpdateColumn(columnIndex, header, unwrap(cells));
+    });
+  }
+  UpdateColumn(tableName, columnIndex, header, cells) {
+    const this$ = this;
+    const tableIndex = ArcTablesAux_findIndexByTableName(tableName, this$.Tables) | 0;
+    this$.UpdateColumnAt(tableIndex, columnIndex, header, unwrap(cells));
+  }
+  GetColumnAt(tableIndex, columnIndex) {
+    const this$ = this;
+    const table = this$.GetTableAt(tableIndex);
+    return table.GetColumn(columnIndex);
+  }
+  GetColumn(tableName, columnIndex) {
+    const this$ = this;
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), columnIndex];
+    return this$.GetColumnAt(tupledArg[0], tupledArg[1]);
+  }
+  AddRowAt(tableIndex, cells, rowIndex) {
+    const this$ = this;
+    this$.MapTableAt(tableIndex, (table) => {
+      table.AddRow(unwrap(cells), unwrap(rowIndex));
+    });
+  }
+  AddRow(tableName, cells, rowIndex) {
+    const this$ = this;
+    const i = ArcTablesAux_findIndexByTableName(tableName, this$.Tables) | 0;
+    this$.AddRowAt(i, unwrap(cells), unwrap(rowIndex));
+  }
+  RemoveRowAt(tableIndex, rowIndex) {
+    const this$ = this;
+    this$.MapTableAt(tableIndex, (table) => {
+      table.RemoveRow(rowIndex);
+    });
+  }
+  RemoveRow(tableName, rowIndex) {
+    const this$ = this;
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), rowIndex];
+    this$.RemoveRowAt(tupledArg[0], tupledArg[1]);
+  }
+  UpdateRowAt(tableIndex, rowIndex, cells) {
+    const this$ = this;
+    this$.MapTableAt(tableIndex, (table) => {
+      table.UpdateRow(rowIndex, cells);
+    });
+  }
+  UpdateRow(tableName, rowIndex, cells) {
+    const this$ = this;
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), rowIndex, cells];
+    this$.UpdateRowAt(tupledArg[0], tupledArg[1], tupledArg[2]);
+  }
+  GetRowAt(tableIndex, rowIndex) {
+    const this$ = this;
+    const table = this$.GetTableAt(tableIndex);
+    return table.GetRow(rowIndex);
+  }
+  GetRow(tableName, rowIndex) {
+    const this$ = this;
+    const tupledArg = [ArcTablesAux_findIndexByTableName(tableName, this$.Tables), rowIndex];
+    return this$.GetRowAt(tupledArg[0], tupledArg[1]);
+  }
+  static ofSeq(tables) {
+    return new ArcTables(Array.from(tables));
+  }
+  MoveTable(oldIndex, newIndex) {
+    const this$ = this;
+    const table = this$.GetTableAt(oldIndex);
+    this$.Tables.splice(oldIndex, 1);
+    this$.Tables.splice(newIndex, 0, table);
+  }
+  static updateReferenceTablesBySheets(referenceTables, sheetTables, keepUnusedRefTables) {
+    let collection, s, a;
+    const keepUnusedRefTables_1 = defaultArg(keepUnusedRefTables, false);
+    const usedTables = /* @__PURE__ */ new Set([]);
+    const referenceTableMap = ofSeq(choose((t) => map$1((c) => [c.Cells[0].AsFreeText, t], t.TryGetProtocolNameColumn()), referenceTables.Tables), {
+      Compare: comparePrimitives
+    });
+    return new ArcTables((collection = (s = ResizeArray_map((tupledArg) => reduce((table, table_1) => ArcTable.append(table, table_1), tupledArg[1]), ResizeArray_groupBy((t_2) => t_2.Name, ResizeArray_map((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, CompositeHeader_ProtocolREF()), t_1.Headers))), t_1.Name);
+      const matchValue = tryFind(k, referenceTableMap);
+      if (matchValue == null) {
+        return t_1;
+      } else {
+        const rt = value(matchValue);
+        addToSet(k, usedTables);
+        const updatedTable = ArcTable.updateReferenceByAnnotationTable(rt, t_1);
+        return ArcTable.fromArcTableValues(t_1.Name, updatedTable.Headers, updatedTable.Values);
+      }
+    }, (a = sheetTables.Tables, ResizeArray_collect(ArcTable.SplitByProtocolREF, a))))), keepUnusedRefTables_1 ? append(choose((kv) => {
+      if (usedTables.has(kv[0])) {
+        return void 0;
+      } else {
+        return kv[1];
+      }
+    }, referenceTableMap), s) : s), Array.from(collection)));
+  }
+  GetEnumerator() {
+    const this$ = this;
+    return getEnumerator(this$.Tables);
+  }
+  [Symbol.iterator]() {
+    return toIterator(getEnumerator(this));
+  }
+  "System.Collections.IEnumerable.GetEnumerator"() {
+    const this$ = this;
+    return getEnumerator(this$.Tables);
+  }
+}
+
+export { ArcTables, ArcTablesAux_SanityChecks_validateNamesUnique, ArcTablesAux_SanityChecks_validateNewNameAtUnique, ArcTablesAux_SanityChecks_validateNewNameUnique, ArcTablesAux_SanityChecks_validateNewNamesUnique, ArcTablesAux_SanityChecks_validateSheetIndex, ArcTablesAux_applyIOMap, ArcTablesAux_findIndexByTableName, ArcTablesAux_getIOMap, ArcTablesAux_tryFindIndexByTableName };