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

package/dist/ts/ts/Core/Conversion.js

@@ -0,0 +1,923 @@
+import { toText, printf, toFail } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { Comment$ } from './Comment.js';
+import { tryPick, toList, delay, choose, fold, indexed, map as map$2, append as append$1, singleton as singleton$1, empty as empty$1, zip as zip$1, filter } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { value, unwrap, defaultArg, map as map$1 } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { ResizeArray_filter, Option_fromValueWithDefault } from './Helper/Collections.js';
+import { OntologyAnnotation } from './OntologyAnnotation.js';
+import { Value_Name, Value, Value_Ontology } from './Value.js';
+import { CompositeCell_FreeText, CompositeCell_Unitized, CompositeCell_Term } from './Table/CompositeCell.js';
+import { Component_create_Z2F0B38C7 } from './Process/Component.js';
+import { CompositeHeader_Comment, CompositeHeader_Parameter, CompositeHeader_Component, CompositeHeader_Characteristic, CompositeHeader_Factor, CompositeHeader_ProtocolREF, CompositeHeader_Input, IOType_Source, IOType_Data, IOType_Material, IOType_Sample, CompositeHeader_ProtocolType, CompositeHeader_ProtocolDescription, CompositeHeader_ProtocolUri, CompositeHeader_ProtocolVersion, CompositeHeader_Output } from './Table/CompositeHeader.js';
+import { ProtocolParameter } from './Process/ProtocolParameter.js';
+import { ProcessParameterValue } from './Process/ProcessParameterValue.js';
+import { FactorValue_create_30BDC49 } from './Process/FactorValue.js';
+import { Factor } from './Process/Factor.js';
+import { toString } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { MaterialAttributeValue_create_ZE1D108D } from './Process/MaterialAttributeValue.js';
+import { MaterialAttribute_create_A220A8A } from './Process/MaterialAttribute.js';
+import { ProcessInput__get_Name, ProcessInput__isSource, ProcessInput__isSample, ProcessInput__isData, ProcessInput__isMaterial, ProcessInput_getCharacteristicValues_5B3D5BA9, ProcessInput_createSource_Z5E00540E, ProcessInput_createMaterial_4452CB4C, ProcessInput_createRawData_Z721C83C5, ProcessInput_createSample_Z598187B7, ProcessInput_Source, ProcessInput_setCharacteristicValues } from './Process/ProcessInput.js';
+import { ProcessOutput__get_Name, ProcessOutput__isSample, ProcessOutput__isData, ProcessOutput__isMaterial, ProcessOutput_getFactorValues_Z42C11600, ProcessOutput_createMaterial_4452CB4C, ProcessOutput_createRawData_Z721C83C5, ProcessOutput_createSample_Z598187B7, ProcessOutput_Sample, ProcessOutput_setFactorValues } from './Process/ProcessOutput.js';
+import { int32ToString, comparePrimitives, safeHash, equals, stringHash, arrayHash, equalArrays } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { ActivePatterns_$007CRegex$007C_$007C } from './Helper/Regex.js';
+import { tryGetParameterColumnIndex, tryGetComponentIndex, tryGetCharacteristicColumnIndex, tryGetFactorColumnIndex, ARCtrl_OntologyAnnotation__OntologyAnnotation_setColumnIndex_Static, ARCtrl_OntologyAnnotation__OntologyAnnotation_SetColumnIndex_Z524259A4 } from './Process/ColumnIndex.js';
+import { Unchecked_alignByHeaders, Unchecked_tryGetCellAt, getEmptyCellForHeader } from './Table/ArcTableAux.js';
+import { ArcTable } from './Table/ArcTable.js';
+import { map, collect, empty, zip, head, tryPick as tryPick$1, sortBy, append, singleton, initialize, choose as choose$1, ofArray, length, item, mapIndexed, isEmpty } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { Source_create_Z5CA08497 } from './Process/Source.js';
+import { Sample_create_62424AD2 } from './Process/Sample.js';
+import { Process_create_Z7C1F7FA9, Process_composeName, Process_make, Process_decomposeName_Z721C83C5 } from './Process/Process.js';
+import { Protocol_create_Z414665E7, Protocol_addComponent, Protocol_addParameter, Protocol_setName, Protocol_setDescription, Protocol_setUri, Protocol_setVersion, Protocol_setProtocolType, Protocol_make } from './Process/Protocol.js';
+import { List_groupBy, List_distinct } from '../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { createMissingIdentifier } from './Helper/Identifier.js';
+import { boxHashOption, boxHashSeq } from './Helper/HashCodes.js';
+import { rangeDouble } from '../../node_modules/@fable-org/fable-library-js/Range.js';
+import { ArcTables } from './Table/ArcTables.js';
+
+const Person_orcidKey = "ORCID";
+const Person_AssayIdentifierPrefix = "performer (ARC:00000168)";
+const Person_createAssayIdentifierKey = (() => {
+  const clo_1 = toText(printf("%s %s"))(Person_AssayIdentifierPrefix);
+  return clo_1;
+})();
+function Person_setSourceAssayComment(person, assayIdentifier) {
+  const person_1 = person.Copy();
+  const comment = new Comment$(Person_createAssayIdentifierKey(assayIdentifier), assayIdentifier);
+  void person_1.Comments.push(comment);
+  return person_1;
+}
+function Person_getSourceAssayIdentifiersFromComments(person) {
+  return choose((c) => {
+    if (defaultArg(map$1((n) => n.startsWith(Person_AssayIdentifierPrefix), c.Name), false)) {
+      return c.Value;
+    } else {
+      return void 0;
+    }
+  }, person.Comments);
+}
+function Person_removeSourceAssayComments(person) {
+  return ResizeArray_filter((c) => {
+    if (c.Name != null) {
+      return !value(c.Name).startsWith(Person_AssayIdentifierPrefix);
+    } else {
+      return false;
+    }
+  }, person.Comments);
+}
+function Person_setOrcidFromComments(person) {
+  const person_1 = person.Copy();
+  const isOrcidComment = (c) => {
+    if (c.Name != null) {
+      return value(c.Name).toLocaleUpperCase().endsWith(Person_orcidKey);
+    } else {
+      return false;
+    }
+  };
+  const patternInput = [tryPick((c_1) => {
+    if (isOrcidComment(c_1)) {
+      return c_1.Value;
+    } else {
+      return void 0;
+    }
+  }, person_1.Comments), ResizeArray_filter((arg) => !isOrcidComment(arg), person_1.Comments)];
+  person_1.ORCID = patternInput[0];
+  person_1.Comments = patternInput[1];
+  return person_1;
+}
+function Person_setCommentFromORCID(person) {
+  const person_1 = person.Copy();
+  const matchValue = person_1.ORCID;
+  if (matchValue == null) ; else {
+    const orcid = value(matchValue);
+    const comment = Comment$.create(Person_orcidKey, orcid);
+    void person_1.Comments.push(comment);
+  }
+  return person_1;
+}
+function JsonTypes_valueOfCell(value) {
+  let term;
+  switch (value.tag) {
+    case /* Term */
+    0:
+      if (term = value.fields[0], term.isEmpty()) {
+        value.fields[0];
+        return [void 0, void 0];
+      } else {
+        const term_2 = value.fields[0];
+        return [Value_Ontology(term_2), void 0];
+      }
+    case /* Unitized */
+    2: {
+      const text_1 = value.fields[0];
+      const unit = value.fields[1];
+      return [text_1 === "" ? void 0 : Value.fromString(text_1), unit.isEmpty() ? void 0 : unit];
+    }
+    case /* Data */
+    3: {
+      value.fields[0];
+      throw new Error("Data cell should not be parsed to isa value");
+    }
+    default:
+      if (value.fields[0] === "") {
+        return [void 0, void 0];
+      } else {
+        const text = value.fields[0];
+        return [Value.fromString(text), void 0];
+      }
+  }
+}
+function JsonTypes_composeComponent(header, value) {
+  const patternInput = JsonTypes_valueOfCell(value);
+  return Component_create_Z2F0B38C7(unwrap(patternInput[0]), unwrap(patternInput[1]), header.ToTerm());
+}
+function JsonTypes_composeParameterValue(header, value) {
+  const patternInput = JsonTypes_valueOfCell(value);
+  const p = ProtocolParameter.create(void 0, header.ToTerm());
+  return ProcessParameterValue.create(p, unwrap(patternInput[0]), unwrap(patternInput[1]));
+}
+function JsonTypes_composeFactorValue(header, value) {
+  const patternInput = JsonTypes_valueOfCell(value);
+  return FactorValue_create_30BDC49(void 0, Factor.create(toString(header), header.ToTerm()), unwrap(patternInput[0]), unwrap(patternInput[1]));
+}
+function JsonTypes_composeCharacteristicValue(header, value) {
+  const patternInput = JsonTypes_valueOfCell(value);
+  return MaterialAttributeValue_create_ZE1D108D(void 0, MaterialAttribute_create_A220A8A(void 0, header.ToTerm()), unwrap(patternInput[0]), unwrap(patternInput[1]));
+}
+function JsonTypes_composeFreetextMaterialName(headerFT, name) {
+  return `${headerFT}=${name}`;
+}
+function JsonTypes_composeProcessInput(header, value) {
+  if (header.tag === /* Input */
+  11) {
+    switch (header.fields[0].tag) {
+      case /* Sample */
+      1:
+        return ProcessInput_createSample_Z598187B7(toString(value));
+      case /* Material */
+      3:
+        return ProcessInput_createMaterial_4452CB4C(toString(value));
+      case /* Data */
+      2:
+        return ProcessInput_createRawData_Z721C83C5(toString(value));
+      case /* FreeText */
+      4: {
+        const ft = header.fields[0].fields[0];
+        return ProcessInput_createMaterial_4452CB4C(JsonTypes_composeFreetextMaterialName(ft, toString(value)));
+      }
+      default:
+        return ProcessInput_createSource_Z5E00540E(toString(value));
+    }
+  } else {
+    return toFail(printf("Could not parse input header %O"))(header);
+  }
+}
+function JsonTypes_composeProcessOutput(header, value) {
+  let matchResult, ft;
+  if (header.tag === /* Output */
+  12) {
+    switch (header.fields[0].tag) {
+      case /* Material */
+      3: {
+        matchResult = 1;
+        break;
+      }
+      case /* Data */
+      2: {
+        matchResult = 2;
+        break;
+      }
+      case /* FreeText */
+      4: {
+        matchResult = 3;
+        ft = header.fields[0].fields[0];
+        break;
+      }
+      default:
+        matchResult = 0;
+    }
+  } else {
+    matchResult = 4;
+  }
+  switch (matchResult) {
+    case 0:
+      return ProcessOutput_createSample_Z598187B7(toString(value));
+    case 1:
+      return ProcessOutput_createMaterial_4452CB4C(toString(value));
+    case 2:
+      return ProcessOutput_createRawData_Z721C83C5(toString(value));
+    case 3:
+      return ProcessOutput_createMaterial_4452CB4C(JsonTypes_composeFreetextMaterialName(ft, toString(value)));
+    default:
+      return toFail(printf("Could not parse output header %O"))(header);
+  }
+}
+function JsonTypes_cellOfValue(value$1, unit) {
+  const value_2 = defaultArg(value$1, Value_Name(""));
+  let matchResult, oa, text, name, u, f, u_1, f_1, i, u_2, i_1;
+  switch (value_2.tag) {
+    case /* Name */
+    3: {
+      if (value_2.fields[0] === "") {
+        if (unit != null) {
+          matchResult = 3;
+          name = value_2.fields[0];
+          u = value(unit);
+        } else {
+          matchResult = 1;
+        }
+      } else if (unit != null) {
+        matchResult = 3;
+        name = value_2.fields[0];
+        u = value(unit);
+      } else {
+        matchResult = 2;
+        text = value_2.fields[0];
+      }
+      break;
+    }
+    case /* Float */
+    2: {
+      if (unit == null) {
+        matchResult = 5;
+        f_1 = value_2.fields[0];
+      } else {
+        matchResult = 4;
+        f = value_2.fields[0];
+        u_1 = value(unit);
+      }
+      break;
+    }
+    case /* Int */
+    1: {
+      if (unit == null) {
+        matchResult = 7;
+        i_1 = value_2.fields[0];
+      } else {
+        matchResult = 6;
+        i = value_2.fields[0];
+        u_2 = value(unit);
+      }
+      break;
+    }
+    default:
+      if (unit == null) {
+        matchResult = 0;
+        oa = value_2.fields[0];
+      } else {
+        matchResult = 8;
+      }
+  }
+  switch (matchResult) {
+    case 0:
+      return CompositeCell_Term(oa);
+    case 1:
+      return CompositeCell_Term(new OntologyAnnotation());
+    case 2:
+      return CompositeCell_Term(new OntologyAnnotation(text));
+    case 3:
+      return CompositeCell_Unitized(name, u);
+    case 4:
+      return CompositeCell_Unitized(f.toString(), u_1);
+    case 5:
+      return CompositeCell_Unitized(f_1.toString(), new OntologyAnnotation());
+    case 6:
+      return CompositeCell_Unitized(int32ToString(i), u_2);
+    case 7:
+      return CompositeCell_Unitized(int32ToString(i_1), new OntologyAnnotation());
+    default:
+      return toFail(printf("Could not parse value %O with unit %O"))(value_2)(unit);
+  }
+}
+function JsonTypes_decomposeComponent(c) {
+  return [CompositeHeader_Component(value(c.ComponentType)), JsonTypes_cellOfValue(c.ComponentValue, c.ComponentUnit)];
+}
+function JsonTypes_decomposeParameterValue(ppv) {
+  return [CompositeHeader_Parameter(value(value(ppv.Category).ParameterName)), JsonTypes_cellOfValue(ppv.Value, ppv.Unit)];
+}
+function JsonTypes_decomposeFactorValue(fv) {
+  return [CompositeHeader_Factor(value(value(fv.Category).FactorType)), JsonTypes_cellOfValue(fv.Value, fv.Unit)];
+}
+function JsonTypes_decomposeCharacteristicValue(cv) {
+  return [CompositeHeader_Characteristic(value(value(cv.Category).CharacteristicType)), JsonTypes_cellOfValue(cv.Value, cv.Unit)];
+}
+function JsonTypes_decomposeProcessInput(pi) {
+  switch (pi.tag) {
+    case /* Sample */
+    1:
+      return [CompositeHeader_Input(IOType_Sample()), CompositeCell_FreeText(defaultArg(pi.fields[0].Name, ""))];
+    case /* Material */
+    3:
+      return [CompositeHeader_Input(IOType_Material()), CompositeCell_FreeText(defaultArg(pi.fields[0].Name, ""))];
+    case /* Data */
+    2: {
+      const d = pi.fields[0];
+      const dataType = value(d.DataType);
+      switch (dataType.tag) {
+        case /* RawDataFile */
+        0:
+          return [CompositeHeader_Input(IOType_Data()), CompositeCell_FreeText(defaultArg(d.Name, ""))];
+        case /* DerivedDataFile */
+        1:
+          return [CompositeHeader_Input(IOType_Data()), CompositeCell_FreeText(defaultArg(d.Name, ""))];
+        default:
+          return [CompositeHeader_Input(IOType_Data()), CompositeCell_FreeText(defaultArg(d.Name, ""))];
+      }
+    }
+    default:
+      return [CompositeHeader_Input(IOType_Source()), CompositeCell_FreeText(defaultArg(pi.fields[0].Name, ""))];
+  }
+}
+function JsonTypes_decomposeProcessOutput(po) {
+  switch (po.tag) {
+    case /* Material */
+    2:
+      return [CompositeHeader_Output(IOType_Material()), CompositeCell_FreeText(defaultArg(po.fields[0].Name, ""))];
+    case /* Data */
+    1: {
+      const d = po.fields[0];
+      const dataType = value(d.DataType);
+      switch (dataType.tag) {
+        case /* RawDataFile */
+        0:
+          return [CompositeHeader_Output(IOType_Data()), CompositeCell_FreeText(defaultArg(d.Name, ""))];
+        case /* DerivedDataFile */
+        1:
+          return [CompositeHeader_Output(IOType_Data()), CompositeCell_FreeText(defaultArg(d.Name, ""))];
+        default:
+          return [CompositeHeader_Output(IOType_Data()), CompositeCell_FreeText(defaultArg(d.Name, ""))];
+      }
+    }
+    default:
+      return [CompositeHeader_Output(IOType_Sample()), CompositeCell_FreeText(defaultArg(po.fields[0].Name, ""))];
+  }
+}
+function JsonTypes_composeTechnologyPlatform(tp) {
+  const matchValue = tp.TANInfo;
+  if (matchValue == null) {
+    return `${tp.NameText}`;
+  } else {
+    return `${tp.NameText} (${tp.TermAccessionShort})`;
+  }
+}
+function JsonTypes_decomposeTechnologyPlatform(name) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("^(?<value>.+) \\((?<ontology>[^(]*:[^)]*)\\)$", name);
+  if (activePatternResult != null) {
+    const r = value(activePatternResult);
+    let oa;
+    const tan = r.groups && r.groups.ontology || "";
+    oa = OntologyAnnotation.fromTermAnnotation(tan);
+    const v = r.groups && r.groups.value || "";
+    return OntologyAnnotation.create(v, unwrap(oa.TermSourceREF), unwrap(oa.TermAccessionNumber));
+  } else {
+    return OntologyAnnotation.create(name);
+  }
+}
+function ProcessParsing_tryComponentGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Component */
+  0) {
+    const oa = valueHeader.fields[0];
+    const newOA = oa.Copy();
+    ARCtrl_OntologyAnnotation__OntologyAnnotation_SetColumnIndex_Z524259A4(newOA, valueI);
+    const cat = CompositeHeader_Component(newOA);
+    return (table) => (i) => {
+      let matchValue;
+      return JsonTypes_composeComponent(cat, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(cat, void 0) : value(matchValue)));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryParameterGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Parameter */
+  3) {
+    const cat = CompositeHeader_Parameter(ARCtrl_OntologyAnnotation__OntologyAnnotation_setColumnIndex_Static(valueI, valueHeader.fields[0]));
+    return (table) => (i_1) => {
+      let matchValue;
+      return JsonTypes_composeParameterValue(cat, (matchValue = Unchecked_tryGetCellAt(generalI, i_1, table.Values), matchValue == null ? getEmptyCellForHeader(cat, void 0) : value(matchValue)));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryFactorGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Factor */
+  2) {
+    const cat = CompositeHeader_Factor(ARCtrl_OntologyAnnotation__OntologyAnnotation_setColumnIndex_Static(valueI, valueHeader.fields[0]));
+    return (table) => (i_1) => {
+      let matchValue;
+      return JsonTypes_composeFactorValue(cat, (matchValue = Unchecked_tryGetCellAt(generalI, i_1, table.Values), matchValue == null ? getEmptyCellForHeader(cat, void 0) : value(matchValue)));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryCharacteristicGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Characteristic */
+  1) {
+    const cat = CompositeHeader_Characteristic(ARCtrl_OntologyAnnotation__OntologyAnnotation_setColumnIndex_Static(valueI, valueHeader.fields[0]));
+    return (table) => (i_1) => {
+      let matchValue;
+      return JsonTypes_composeCharacteristicValue(cat, (matchValue = Unchecked_tryGetCellAt(generalI, i_1, table.Values), matchValue == null ? getEmptyCellForHeader(cat, void 0) : value(matchValue)));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryGetProtocolTypeGetter(generalI, header) {
+  if (header.tag === /* ProtocolType */
+  4) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return new OntologyAnnotation();
+      } else {
+        const cell = value(matchValue);
+        return cell.AsTerm;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryGetProtocolREFGetter(generalI, header) {
+  if (header.tag === /* ProtocolREF */
+  8) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return "";
+      } else {
+        const cell = value(matchValue);
+        return cell.AsFreeText;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryGetProtocolDescriptionGetter(generalI, header) {
+  if (header.tag === /* ProtocolDescription */
+  5) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return "";
+      } else {
+        const cell = value(matchValue);
+        return cell.AsFreeText;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryGetProtocolURIGetter(generalI, header) {
+  if (header.tag === /* ProtocolUri */
+  6) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return "";
+      } else {
+        const cell = value(matchValue);
+        return cell.AsFreeText;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryGetProtocolVersionGetter(generalI, header) {
+  if (header.tag === /* ProtocolVersion */
+  7) {
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return "";
+      } else {
+        const cell = value(matchValue);
+        return cell.AsFreeText;
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryGetInputGetter(generalI, header) {
+  if (header.tag === /* Input */
+  11) {
+    header.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      return JsonTypes_composeProcessInput(header, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(header, void 0) : value(matchValue)));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryGetOutputGetter(generalI, header) {
+  if (header.tag === /* Output */
+  12) {
+    header.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      return JsonTypes_composeProcessOutput(header, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(header, void 0) : value(matchValue)));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_tryGetCommentGetter(generalI, header) {
+  if (header.tag === /* Comment */
+  14) {
+    const c = header.fields[0];
+    return (table) => (i) => {
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        return new Comment$(c);
+      } else {
+        const cell = value(matchValue);
+        return new Comment$(c, cell.AsFreeText);
+      }
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessParsing_getProcessGetter(processNameRoot, headers) {
+  const headers_1 = indexed(headers);
+  const valueHeaders = toList(indexed(filter((arg) => arg[1].IsCvParamColumn, headers_1)));
+  const charGetters = choose$1((tupledArg) => {
+    const _arg = tupledArg[1];
+    return ProcessParsing_tryCharacteristicGetter(_arg[0], tupledArg[0], _arg[1]);
+  }, valueHeaders);
+  const factorValueGetters = choose$1((tupledArg_1) => {
+    const _arg_1 = tupledArg_1[1];
+    return ProcessParsing_tryFactorGetter(_arg_1[0], tupledArg_1[0], _arg_1[1]);
+  }, valueHeaders);
+  const parameterValueGetters = choose$1((tupledArg_2) => {
+    const _arg_2 = tupledArg_2[1];
+    return ProcessParsing_tryParameterGetter(_arg_2[0], tupledArg_2[0], _arg_2[1]);
+  }, valueHeaders);
+  const componentGetters = choose$1((tupledArg_3) => {
+    const _arg_3 = tupledArg_3[1];
+    return ProcessParsing_tryComponentGetter(_arg_3[0], tupledArg_3[0], _arg_3[1]);
+  }, valueHeaders);
+  const protocolTypeGetter = tryPick((tupledArg_4) => ProcessParsing_tryGetProtocolTypeGetter(tupledArg_4[0], tupledArg_4[1]), headers_1);
+  const protocolREFGetter = tryPick((tupledArg_5) => ProcessParsing_tryGetProtocolREFGetter(tupledArg_5[0], tupledArg_5[1]), headers_1);
+  const protocolDescriptionGetter = tryPick((tupledArg_6) => ProcessParsing_tryGetProtocolDescriptionGetter(tupledArg_6[0], tupledArg_6[1]), headers_1);
+  const protocolURIGetter = tryPick((tupledArg_7) => ProcessParsing_tryGetProtocolURIGetter(tupledArg_7[0], tupledArg_7[1]), headers_1);
+  const protocolVersionGetter = tryPick((tupledArg_8) => ProcessParsing_tryGetProtocolVersionGetter(tupledArg_8[0], tupledArg_8[1]), headers_1);
+  const commentGetters = toList(choose((tupledArg_9) => ProcessParsing_tryGetCommentGetter(tupledArg_9[0], tupledArg_9[1]), headers_1));
+  let inputGetter_1;
+  const matchValue = tryPick((tupledArg_10) => ProcessParsing_tryGetInputGetter(tupledArg_10[0], tupledArg_10[1]), headers_1);
+  if (matchValue == null) {
+    inputGetter_1 = (table_1) => (i_1) => singleton(ProcessInput_Source(Source_create_Z5CA08497(void 0, `${processNameRoot}_Input_${i_1}`, toList(map$2((f_1) => f_1(table_1)(i_1), charGetters)))));
+  } else {
+    const inputGetter = value(matchValue);
+    inputGetter_1 = (table) => (i) => {
+      const chars = toList(map$2((f) => f(table)(i), charGetters));
+      const input = inputGetter(table)(i);
+      return !(ProcessInput__isSample(input) ? true : ProcessInput__isSource(input)) && !isEmpty(chars) ? ofArray([input, ProcessInput_createSample_Z598187B7(ProcessInput__get_Name(input), chars)]) : singleton(length(chars) > 0 ? ProcessInput_setCharacteristicValues(chars, input) : input);
+    };
+  }
+  let outputGetter_1;
+  const matchValue_1 = tryPick((tupledArg_11) => ProcessParsing_tryGetOutputGetter(tupledArg_11[0], tupledArg_11[1]), headers_1);
+  if (matchValue_1 == null) {
+    outputGetter_1 = (table_3) => (i_3) => singleton(ProcessOutput_Sample(Sample_create_62424AD2(void 0, `${processNameRoot}_Output_${i_3}`, void 0, toList(map$2((f_3) => f_3(table_3)(i_3), factorValueGetters)))));
+  } else {
+    const outputGetter = value(matchValue_1);
+    outputGetter_1 = (table_2) => (i_2) => {
+      const factors = toList(map$2((f_2) => f_2(table_2)(i_2), factorValueGetters));
+      const output = outputGetter(table_2)(i_2);
+      return !ProcessOutput__isSample(output) && !isEmpty(factors) ? ofArray([output, ProcessOutput_createSample_Z598187B7(ProcessOutput__get_Name(output), void 0, factors)]) : singleton(length(factors) > 0 ? ProcessOutput_setFactorValues(factors, output) : output);
+    };
+  }
+  return (table_4) => (i_4) => {
+    const pn = map$1((p) => Process_composeName(p, i_4), Option_fromValueWithDefault("", processNameRoot));
+    const paramvalues = Option_fromValueWithDefault(empty(), map((f_4) => f_4(table_4)(i_4), parameterValueGetters));
+    const parameters = map$1((list_5) => map((pv) => value(pv.Category), list_5), paramvalues);
+    const comments = Option_fromValueWithDefault(empty(), map((f_5) => f_5(table_4)(i_4), commentGetters));
+    let protocol;
+    const p_1 = Protocol_make(void 0, map$1((f_6) => f_6(table_4)(i_4), protocolREFGetter), map$1((f_7) => f_7(table_4)(i_4), protocolTypeGetter), map$1((f_8) => f_8(table_4)(i_4), protocolDescriptionGetter), map$1((f_9) => f_9(table_4)(i_4), protocolURIGetter), map$1((f_10) => f_10(table_4)(i_4), protocolVersionGetter), parameters, Option_fromValueWithDefault(empty(), map((f_11) => f_11(table_4)(i_4), componentGetters)), void 0);
+    let matchResult;
+    if (p_1.Name == null) {
+      if (p_1.ProtocolType == null) {
+        if (p_1.Description == null) {
+          if (p_1.Uri == null) {
+            if (p_1.Version == null) {
+              if (p_1.Components == null) {
+                matchResult = 0;
+              } else {
+                matchResult = 1;
+              }
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0: {
+        protocol = void 0;
+        break;
+      }
+      default:
+        protocol = p_1;
+    }
+    let patternInput;
+    const inputs = inputGetter_1(table_4)(i_4);
+    const outputs = outputGetter_1(table_4)(i_4);
+    patternInput = length(inputs) === 1 && length(outputs) === 2 ? [ofArray([item(0, inputs), item(0, inputs)]), outputs] : length(inputs) === 2 && length(outputs) === 1 ? [inputs, ofArray([item(0, outputs), item(0, outputs)])] : [inputs, outputs];
+    return Process_make(void 0, pn, protocol, paramvalues, void 0, void 0, void 0, void 0, patternInput[0], patternInput[1], comments);
+  };
+}
+function ProcessParsing_groupProcesses(ps) {
+  return List_groupBy((x) => {
+    if (x.Name != null && Process_decomposeName_Z721C83C5(value(x.Name))[1] != null) {
+      return Process_decomposeName_Z721C83C5(value(x.Name))[0];
+    } else if (x.ExecutesProtocol != null && value(x.ExecutesProtocol).Name != null) {
+      return value(value(x.ExecutesProtocol).Name);
+    } else if (x.Name != null) {
+      return value(x.Name);
+    } else if (x.ExecutesProtocol != null && value(x.ExecutesProtocol).ID != null) {
+      return value(value(x.ExecutesProtocol).ID);
+    } else {
+      return createMissingIdentifier();
+    }
+  }, ps, {
+    Equals: (x_1, y) => x_1 === y,
+    GetHashCode: stringHash
+  });
+}
+function ProcessParsing_mergeIdenticalProcesses(processes) {
+  const l = List_groupBy((x) => {
+    if (x.Name != null && Process_decomposeName_Z721C83C5(value(x.Name))[1] != null) {
+      return [Process_decomposeName_Z721C83C5(value(x.Name))[0], boxHashOption(x.ExecutesProtocol), map$1(boxHashSeq, x.ParameterValues), map$1(boxHashSeq, x.Comments)];
+    } else if (x.ExecutesProtocol != null && value(x.ExecutesProtocol).Name != null) {
+      return [value(value(x.ExecutesProtocol).Name), boxHashOption(x.ExecutesProtocol), map$1(boxHashSeq, x.ParameterValues), map$1(boxHashSeq, x.Comments)];
+    } else {
+      return [createMissingIdentifier(), boxHashOption(x.ExecutesProtocol), map$1(boxHashSeq, x.ParameterValues), map$1(boxHashSeq, x.Comments)];
+    }
+  }, processes, {
+    Equals: equalArrays,
+    GetHashCode: arrayHash
+  });
+  return mapIndexed((i, tupledArg) => {
+    const processes_1 = tupledArg[1];
+    const n = tupledArg[0][0];
+    const pVs = item(0, processes_1).ParameterValues;
+    const inputs = Option_fromValueWithDefault(empty(), collect((p) => defaultArg(p.Inputs, empty()), processes_1));
+    const outputs = Option_fromValueWithDefault(empty(), collect((p_1) => defaultArg(p_1.Outputs, empty()), processes_1));
+    return Process_create_Z7C1F7FA9(void 0, length(l) > 1 ? Process_composeName(n, i) : n, unwrap(item(0, processes_1).ExecutesProtocol), unwrap(pVs), void 0, void 0, void 0, void 0, unwrap(inputs), unwrap(outputs), unwrap(item(0, processes_1).Comments));
+  }, l);
+}
+function ProcessParsing_processToRows(p) {
+  let list_4;
+  const pvs = map((ppv) => [JsonTypes_decomposeParameterValue(ppv), tryGetParameterColumnIndex(ppv)], defaultArg(p.ParameterValues, empty()));
+  let components;
+  const matchValue = p.ExecutesProtocol;
+  components = matchValue == null ? empty() : map((ppv_1) => [JsonTypes_decomposeComponent(ppv_1), tryGetComponentIndex(ppv_1)], defaultArg(value(matchValue).Components, empty()));
+  let protVals;
+  const matchValue_1 = p.ExecutesProtocol;
+  if (matchValue_1 == null) {
+    protVals = empty();
+  } else {
+    const prot_1 = value(matchValue_1);
+    protVals = toList(delay(() => append$1(prot_1.Name != null ? singleton$1([CompositeHeader_ProtocolREF(), CompositeCell_FreeText(value(prot_1.Name))]) : empty$1(), delay(() => append$1(prot_1.ProtocolType != null ? singleton$1([CompositeHeader_ProtocolType(), CompositeCell_Term(value(prot_1.ProtocolType))]) : empty$1(), delay(() => append$1(prot_1.Description != null ? singleton$1([CompositeHeader_ProtocolDescription(), CompositeCell_FreeText(value(prot_1.Description))]) : empty$1(), delay(() => append$1(prot_1.Uri != null ? singleton$1([CompositeHeader_ProtocolUri(), CompositeCell_FreeText(value(prot_1.Uri))]) : empty$1(), delay(() => prot_1.Version != null ? singleton$1([CompositeHeader_ProtocolVersion(), CompositeCell_FreeText(value(prot_1.Version))]) : empty$1()))))))))));
+  }
+  const comments = map((c) => [CompositeHeader_Comment(defaultArg(c.Name, "")), CompositeCell_FreeText(defaultArg(c.Value, ""))], defaultArg(p.Comments, empty()));
+  return map((tupledArg_1) => {
+    const ios = tupledArg_1[1];
+    const inputForCharas = defaultArg(tryPick$1((tupledArg_2) => {
+      const i_2 = tupledArg_2[0];
+      if (ProcessInput__isSource(i_2) ? true : ProcessInput__isSample(i_2)) {
+        return i_2;
+      } else {
+        return void 0;
+      }
+    }, ios), head(ios)[0]);
+    const inputForType = defaultArg(tryPick$1((tupledArg_3) => {
+      const i_3 = tupledArg_3[0];
+      if (ProcessInput__isData(i_3) ? true : ProcessInput__isMaterial(i_3)) {
+        return i_3;
+      } else {
+        return void 0;
+      }
+    }, ios), head(ios)[0]);
+    const chars = map((cv) => [JsonTypes_decomposeCharacteristicValue(cv), tryGetCharacteristicColumnIndex(cv)], ProcessInput_getCharacteristicValues_5B3D5BA9(inputForCharas));
+    const outputForFactors = defaultArg(tryPick$1((tupledArg_4) => {
+      const o_4 = tupledArg_4[1];
+      if (ProcessOutput__isSample(o_4)) {
+        return o_4;
+      } else {
+        return void 0;
+      }
+    }, ios), head(ios)[1]);
+    const outputForType = defaultArg(tryPick$1((tupledArg_5) => {
+      const o_5 = tupledArg_5[1];
+      if (ProcessOutput__isData(o_5) ? true : ProcessOutput__isMaterial(o_5)) {
+        return o_5;
+      } else {
+        return void 0;
+      }
+    }, ios), head(ios)[1]);
+    const vals = map((tuple_5) => tuple_5[0], sortBy((arg) => defaultArg(arg[1], 1e4), append(chars, append(components, append(pvs, map((fv) => [JsonTypes_decomposeFactorValue(fv), tryGetFactorColumnIndex(fv)], ProcessOutput_getFactorValues_Z42C11600(outputForFactors))))), {
+      Compare: comparePrimitives
+    }));
+    return toList(delay(() => append$1(singleton$1(JsonTypes_decomposeProcessInput(inputForType)), delay(() => append$1(protVals, delay(() => append$1(vals, delay(() => append$1(comments, delay(() => singleton$1(JsonTypes_decomposeProcessOutput(outputForType))))))))))));
+  }, List_groupBy((tupledArg) => [ProcessInput__get_Name(tupledArg[0]), ProcessOutput__get_Name(tupledArg[1])], (list_4 = defaultArg(p.Outputs, empty()), zip(defaultArg(p.Inputs, empty()), list_4)), {
+    Equals: equalArrays,
+    GetHashCode: arrayHash
+  }));
+}
+function CompositeRow_toProtocol(tableName, row) {
+  return fold((p, hc) => {
+    let matchResult, oa, v, v_1, v_2, v_3, oa_1, oa_2, unit, v_4, oa_3, t;
+    switch (hc[0].tag) {
+      case /* ProtocolType */
+      4: {
+        if (hc[1].tag === /* Term */
+        0) {
+          matchResult = 0;
+          oa = hc[1].fields[0];
+        } else {
+          matchResult = 8;
+        }
+        break;
+      }
+      case /* ProtocolVersion */
+      7: {
+        if (hc[1].tag === /* FreeText */
+        1) {
+          matchResult = 1;
+          v = hc[1].fields[0];
+        } else {
+          matchResult = 8;
+        }
+        break;
+      }
+      case /* ProtocolUri */
+      6: {
+        if (hc[1].tag === /* FreeText */
+        1) {
+          matchResult = 2;
+          v_1 = hc[1].fields[0];
+        } else {
+          matchResult = 8;
+        }
+        break;
+      }
+      case /* ProtocolDescription */
+      5: {
+        if (hc[1].tag === /* FreeText */
+        1) {
+          matchResult = 3;
+          v_2 = hc[1].fields[0];
+        } else {
+          matchResult = 8;
+        }
+        break;
+      }
+      case /* ProtocolREF */
+      8: {
+        if (hc[1].tag === /* FreeText */
+        1) {
+          matchResult = 4;
+          v_3 = hc[1].fields[0];
+        } else {
+          matchResult = 8;
+        }
+        break;
+      }
+      case /* Parameter */
+      3: {
+        matchResult = 5;
+        oa_1 = hc[0].fields[0];
+        break;
+      }
+      case /* Component */
+      0: {
+        switch (hc[1].tag) {
+          case /* Unitized */
+          2: {
+            matchResult = 6;
+            oa_2 = hc[0].fields[0];
+            unit = hc[1].fields[1];
+            v_4 = hc[1].fields[0];
+            break;
+          }
+          case /* Term */
+          0: {
+            matchResult = 7;
+            oa_3 = hc[0].fields[0];
+            t = hc[1].fields[0];
+            break;
+          }
+          default:
+            matchResult = 8;
+        }
+        break;
+      }
+      default:
+        matchResult = 8;
+    }
+    switch (matchResult) {
+      case 0:
+        return Protocol_setProtocolType(p, oa);
+      case 1:
+        return Protocol_setVersion(p, v);
+      case 2:
+        return Protocol_setUri(p, v_1);
+      case 3:
+        return Protocol_setDescription(p, v_2);
+      case 4:
+        return Protocol_setName(p, v_3);
+      case 5:
+        return Protocol_addParameter(ProtocolParameter.create(void 0, oa_1), p);
+      case 6:
+        return Protocol_addComponent(Component_create_Z2F0B38C7(Value.fromString(v_4), unit, oa_2), p);
+      case 7:
+        return Protocol_addComponent(Component_create_Z2F0B38C7(Value_Ontology(t), void 0, oa_3), p);
+      default:
+        return p;
+    }
+  }, Protocol_create_Z414665E7(void 0, tableName), row);
+}
+function ARCtrl_ArcTable__ArcTable_GetProtocols(this$) {
+  let source;
+  if (this$.RowCount === 0) {
+    return singleton((source = this$.Headers, fold((p, h) => {
+      switch (h.tag) {
+        case /* ProtocolType */
+        4:
+          return Protocol_setProtocolType(p, new OntologyAnnotation());
+        case /* ProtocolVersion */
+        7:
+          return Protocol_setVersion(p, "");
+        case /* ProtocolUri */
+        6:
+          return Protocol_setUri(p, "");
+        case /* ProtocolDescription */
+        5:
+          return Protocol_setDescription(p, "");
+        case /* ProtocolREF */
+        8:
+          return Protocol_setName(p, "");
+        case /* Parameter */
+        3: {
+          const oa = h.fields[0];
+          return Protocol_addParameter(ProtocolParameter.create(void 0, oa), p);
+        }
+        case /* Component */
+        0:
+          return Protocol_addComponent(Component_create_Z2F0B38C7(void 0, void 0, h.fields[0]), p);
+        default:
+          return p;
+      }
+    }, Protocol_create_Z414665E7(void 0, this$.Name), source)));
+  } else {
+    return List_distinct(initialize(this$.RowCount, (i) => {
+      let row;
+      const source_2 = this$.GetRow(i, true);
+      row = zip$1(this$.Headers, source_2);
+      return CompositeRow_toProtocol(this$.Name, row);
+    }), {
+      Equals: equals,
+      GetHashCode: safeHash
+    });
+  }
+}
+function ARCtrl_ArcTable__ArcTable_GetProcesses(this$) {
+  if (this$.RowCount === 0) {
+    return singleton(Process_create_Z7C1F7FA9(void 0, this$.Name));
+  } else {
+    let getter;
+    const clo = ProcessParsing_getProcessGetter(this$.Name, this$.Headers);
+    getter = (arg) => {
+      const clo_1 = clo(arg);
+      return clo_1;
+    };
+    return ProcessParsing_mergeIdenticalProcesses(toList(delay(() => map$2((i) => getter(this$)(i), rangeDouble(0, 1, this$.RowCount - 1)))));
+  }
+}
+function ARCtrl_ArcTables__ArcTables_GetProcesses(this$) {
+  return collect(ARCtrl_ArcTable__ArcTable_GetProcesses, toList(this$.Tables));
+}
+function ARCtrl_ArcTables__ArcTables_fromProcesses_Static_62A3309D(ps) {
+  let collection;
+  return new ArcTables((collection = map((tupledArg) => {
+    const tupledArg_1 = Unchecked_alignByHeaders(true, collect(ProcessParsing_processToRows, tupledArg[1]));
+    return ArcTable.fromArcTableValues(tupledArg[0], tupledArg_1[0], tupledArg_1[1]);
+  }, ProcessParsing_groupProcesses(ps)), Array.from(collection)));
+}
+
+export { ARCtrl_ArcTable__ArcTable_GetProcesses, ARCtrl_ArcTable__ArcTable_GetProtocols, ARCtrl_ArcTables__ArcTables_GetProcesses, ARCtrl_ArcTables__ArcTables_fromProcesses_Static_62A3309D, CompositeRow_toProtocol, JsonTypes_cellOfValue, JsonTypes_composeCharacteristicValue, JsonTypes_composeComponent, JsonTypes_composeFactorValue, JsonTypes_composeFreetextMaterialName, JsonTypes_composeParameterValue, JsonTypes_composeProcessInput, JsonTypes_composeProcessOutput, JsonTypes_composeTechnologyPlatform, JsonTypes_decomposeCharacteristicValue, JsonTypes_decomposeComponent, JsonTypes_decomposeFactorValue, JsonTypes_decomposeParameterValue, JsonTypes_decomposeProcessInput, JsonTypes_decomposeProcessOutput, JsonTypes_decomposeTechnologyPlatform, JsonTypes_valueOfCell, Person_AssayIdentifierPrefix, Person_createAssayIdentifierKey, Person_getSourceAssayIdentifiersFromComments, Person_orcidKey, Person_removeSourceAssayComments, Person_setCommentFromORCID, Person_setOrcidFromComments, Person_setSourceAssayComment, ProcessParsing_getProcessGetter, ProcessParsing_groupProcesses, ProcessParsing_mergeIdenticalProcesses, ProcessParsing_processToRows, ProcessParsing_tryCharacteristicGetter, ProcessParsing_tryComponentGetter, ProcessParsing_tryFactorGetter, ProcessParsing_tryGetCommentGetter, ProcessParsing_tryGetInputGetter, ProcessParsing_tryGetOutputGetter, ProcessParsing_tryGetProtocolDescriptionGetter, ProcessParsing_tryGetProtocolREFGetter, ProcessParsing_tryGetProtocolTypeGetter, ProcessParsing_tryGetProtocolURIGetter, ProcessParsing_tryGetProtocolVersionGetter, ProcessParsing_tryParameterGetter };