@nfdi4plants/arctrl 3.0.0-beta.9 → 3.0.1

package/dist/ts/ts/Conversion/Process.js

@@ -0,0 +1,455 @@
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { LDLabProtocol } from '../ROCrate/LDTypes/LabProtocol.js';
+import { unwrap, value, map as map$1, defaultArg } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { OntologyAnnotation } from '../Core/OntologyAnnotation.js';
+import { BaseTypes_decomposeDefinedTerm_Z2F770004, BaseTypes_composeComponent, BaseTypes_composeParameterValue, BaseTypes_composeFactorValue, BaseTypes_composeCharacteristicValue, BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_composeProcessInput, BaseTypes_composeProcessOutput, BaseTypes_decomposeParameterValue_Z2F770004, BaseTypes_decomposeComponent_Z2F770004, BaseTypes_decomposeCharacteristicValue_Z2F770004, BaseTypes_decomposeFactorValue_Z2F770004, BaseTypes_decomposeProcessInput_Z2F770004, BaseTypes_decomposeProcessOutput_Z2F770004 } from './Basic.js';
+import { parse } from '../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { ActivePatterns_$007CRegex$007C_$007C } from '../Core/Helper/Regex.js';
+import { Unchecked_tryGetCellAt, getEmptyCellForHeader } from '../Core/Table/ArcTableAux.js';
+import { ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4, tryGetIndex } from './ColumnIndex.js';
+import { CompositeCell_FreeText, CompositeCell_Term } from '../Core/Table/CompositeCell.js';
+import { CompositeHeader_ProtocolREF, CompositeHeader_ProtocolDescription, CompositeHeader_ProtocolUri, CompositeHeader_ProtocolVersion, CompositeHeader_ProtocolType, CompositeHeader_Comment } from '../Core/Table/CompositeHeader.js';
+import { toString } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { Comment$ } from '../Core/Comment.js';
+import { LDPerson } from '../ROCrate/LDTypes/Person.js';
+import { indexed, toList, filter, tryPick, choose as choose$1, map, delay, append, empty as empty$1, singleton } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { choose, length, empty, map as map$2, sortBy } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { ResizeArray_singleton, Option_fromValueWithDefault, ResizeArray_map, ResizeArray_create, ResizeArray_zip } from '../Core/Helper/Collections.js';
+import { LDSample } from '../ROCrate/LDTypes/Sample.js';
+import { LDLabProcess } from '../ROCrate/LDTypes/LabProcess.js';
+import { List_groupBy } from '../../node_modules/@fable-org/fable-library-js/Seq2.js';
+import { createMissingIdentifier } from '../Core/Helper/Identifier.js';
+import { stringHash, comparePrimitives } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+
+class ProcessConversion {
+  constructor() {
+  }
+}
+function ProcessConversion_$reflection() {
+  return class_type("ARCtrl.Conversion.ProcessConversion", void 0, ProcessConversion);
+}
+function ProcessConversion_tryGetProtocolType_Z6839B9E8(pv, graph, context) {
+  const matchValue = LDLabProtocol.tryGetIntendedUseAsDefinedTerm(pv, unwrap(graph), unwrap(context));
+  if (matchValue == null) {
+    const matchValue_1 = LDLabProtocol.tryGetIntendedUseAsString(pv, unwrap(context));
+    if (matchValue_1 == null) {
+      return void 0;
+    } else {
+      const s = value(matchValue_1);
+      return OntologyAnnotation.create(s);
+    }
+  } else {
+    return BaseTypes_decomposeDefinedTerm_Z2F770004(value(matchValue), unwrap(context));
+  }
+}
+function ProcessConversion_composeProcessName(processNameRoot, i) {
+  return `${processNameRoot}_${i}`;
+}
+function ProcessConversion_decomposeProcessName_Z721C83C5(name) {
+  const activePatternResult = ActivePatterns_$007CRegex$007C_$007C("(?<name>.+)_(?<num>\\d+)", name);
+  if (activePatternResult != null) {
+    const r = value(activePatternResult);
+    return [r.groups && r.groups.name || "", parse(r.groups && r.groups.num || "", 511, false, 32)];
+  } else {
+    return [name, void 0];
+  }
+}
+function ProcessConversion_tryComponentGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Component */
+  0) {
+    const oa = valueHeader.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      const c = BaseTypes_composeComponent(valueHeader, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(valueHeader, void 0) : value(matchValue)));
+      ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(c, valueI);
+      return c;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryParameterGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Parameter */
+  3) {
+    const oa = valueHeader.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      const p = BaseTypes_composeParameterValue(valueHeader, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(valueHeader, void 0) : value(matchValue)));
+      ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(p, valueI);
+      return p;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryFactorGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Factor */
+  2) {
+    const oa = valueHeader.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      const f = BaseTypes_composeFactorValue(valueHeader, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(valueHeader, void 0) : value(matchValue)));
+      ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(f, valueI);
+      return f;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryCharacteristicGetter(generalI, valueI, valueHeader) {
+  if (valueHeader.tag === /* Characteristic */
+  1) {
+    const oa = valueHeader.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      const c = BaseTypes_composeCharacteristicValue(valueHeader, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(valueHeader, void 0) : value(matchValue)));
+      ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(c, valueI);
+      return c;
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetProtocolTypeGetter(generalI, header) {
+  if (header.tag === /* ProtocolType */
+  4) {
+    return (table) => (i) => {
+      let matchValue, cell;
+      return BaseTypes_composeDefinedTerm_ZDED3A0F((matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? new OntologyAnnotation() : (cell = value(matchValue), cell.AsTerm)));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_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 ProcessConversion_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 ProcessConversion_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 ProcessConversion_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 ProcessConversion_tryGetInputGetter(generalI, header, fs) {
+  if (header.tag === /* Input */
+  11) {
+    const io = header.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      return BaseTypes_composeProcessInput(header, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(header, void 0) : value(matchValue)), fs);
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetOutputGetter(generalI, header, fs) {
+  if (header.tag === /* Output */
+  12) {
+    const io = header.fields[0];
+    return (table) => (i) => {
+      let matchValue;
+      return BaseTypes_composeProcessOutput(header, (matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? getEmptyCellForHeader(header, void 0) : value(matchValue)), fs);
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetCommentGetter(generalI, header) {
+  if (header.tag === /* Comment */
+  14) {
+    const c = header.fields[0];
+    return (table) => (i) => {
+      let matchValue, cell;
+      return toString((matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values), matchValue == null ? new Comment$(c) : (cell = value(matchValue), new Comment$(c, cell.AsFreeText))));
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_tryGetPerformerGetter(generalI, header) {
+  if (header.tag === /* Performer */
+  9) {
+    return (table) => (i) => {
+      let performer;
+      const matchValue = Unchecked_tryGetCellAt(generalI, i, table.Values);
+      if (matchValue == null) {
+        performer = "";
+      } else {
+        const cell = value(matchValue);
+        performer = cell.AsFreeText;
+      }
+      return LDPerson.create(performer);
+    };
+  } else {
+    return void 0;
+  }
+}
+function ProcessConversion_getProcessGetter(assayName, studyName, processNameRoot, headers, fs) {
+  const headers_1 = indexed(headers);
+  const valueHeaders = toList(indexed(filter((arg) => arg[1].IsCvParamColumn, headers_1)));
+  const charGetters = choose((tupledArg) => {
+    const _arg = tupledArg[1];
+    return ProcessConversion_tryCharacteristicGetter(_arg[0], tupledArg[0], _arg[1]);
+  }, valueHeaders);
+  const factorValueGetters = choose((tupledArg_1) => {
+    const _arg_1 = tupledArg_1[1];
+    return ProcessConversion_tryFactorGetter(_arg_1[0], tupledArg_1[0], _arg_1[1]);
+  }, valueHeaders);
+  const parameterValueGetters = choose((tupledArg_2) => {
+    const _arg_2 = tupledArg_2[1];
+    return ProcessConversion_tryParameterGetter(_arg_2[0], tupledArg_2[0], _arg_2[1]);
+  }, valueHeaders);
+  const componentGetters = choose((tupledArg_3) => {
+    const _arg_3 = tupledArg_3[1];
+    return ProcessConversion_tryComponentGetter(_arg_3[0], tupledArg_3[0], _arg_3[1]);
+  }, valueHeaders);
+  const protocolTypeGetter = tryPick((tupledArg_4) => ProcessConversion_tryGetProtocolTypeGetter(tupledArg_4[0], tupledArg_4[1]), headers_1);
+  const protocolREFGetter = tryPick((tupledArg_5) => ProcessConversion_tryGetProtocolREFGetter(tupledArg_5[0], tupledArg_5[1]), headers_1);
+  const protocolDescriptionGetter = tryPick((tupledArg_6) => ProcessConversion_tryGetProtocolDescriptionGetter(tupledArg_6[0], tupledArg_6[1]), headers_1);
+  const protocolURIGetter = tryPick((tupledArg_7) => ProcessConversion_tryGetProtocolURIGetter(tupledArg_7[0], tupledArg_7[1]), headers_1);
+  const protocolVersionGetter = tryPick((tupledArg_8) => ProcessConversion_tryGetProtocolVersionGetter(tupledArg_8[0], tupledArg_8[1]), headers_1);
+  const performerGetter = tryPick((tupledArg_9) => ProcessConversion_tryGetPerformerGetter(tupledArg_9[0], tupledArg_9[1]), headers_1);
+  const commentGetters = toList(choose$1((tupledArg_10) => ProcessConversion_tryGetCommentGetter(tupledArg_10[0], tupledArg_10[1]), headers_1));
+  let inputGetter_1;
+  const matchValue = tryPick((tupledArg_11) => ProcessConversion_tryGetInputGetter(tupledArg_11[0], tupledArg_11[1], fs), headers_1);
+  if (matchValue == null) {
+    inputGetter_1 = length(charGetters) !== 0 ? (table_1) => (i_1) => {
+      let chars_1;
+      const collection_1 = map((f_1) => f_1(table_1)(i_1), charGetters);
+      chars_1 = Array.from(collection_1);
+      return ResizeArray_singleton(LDSample.createSample(`${processNameRoot}_Input_${i_1}`, void 0, chars_1));
+    } : (table_2) => (i_2) => [];
+  } else {
+    const inputGetter = value(matchValue);
+    inputGetter_1 = (table) => (i) => {
+      let chars;
+      const collection = map((f) => f(table)(i), charGetters);
+      chars = Array.from(collection);
+      const input = inputGetter(table)(i);
+      if (chars.length > 0) {
+        LDSample.setAdditionalProperties(input, chars);
+      }
+      return ResizeArray_singleton(input);
+    };
+  }
+  let outputGetter_1;
+  const matchValue_1 = tryPick((tupledArg_12) => ProcessConversion_tryGetOutputGetter(tupledArg_12[0], tupledArg_12[1], fs), headers_1);
+  if (matchValue_1 == null) {
+    outputGetter_1 = length(factorValueGetters) !== 0 ? (table_4) => (i_4) => {
+      let factors_1;
+      const collection_3 = map((f_3) => f_3(table_4)(i_4), factorValueGetters);
+      factors_1 = Array.from(collection_3);
+      return ResizeArray_singleton(LDSample.createSample(`${processNameRoot}_Output_${i_4}`, void 0, factors_1));
+    } : (table_5) => (i_5) => [];
+  } else {
+    const outputGetter = value(matchValue_1);
+    outputGetter_1 = (table_3) => (i_3) => {
+      let factors;
+      const collection_2 = map((f_2) => f_2(table_3)(i_3), factorValueGetters);
+      factors = Array.from(collection_2);
+      const output = outputGetter(table_3)(i_3);
+      if (factors.length > 0) {
+        LDSample.setAdditionalProperties(output, factors);
+      }
+      return ResizeArray_singleton(output);
+    };
+  }
+  return (table_6) => (i_6) => {
+    const pn = table_6.RowCount === 1 ? processNameRoot : ProcessConversion_composeProcessName(processNameRoot, i_6);
+    const paramvalues = map$1((collection_4) => Array.from(collection_4), Option_fromValueWithDefault(empty(), map$2((f_4) => f_4(table_6)(i_6), parameterValueGetters)));
+    const comments = map$1((collection_5) => Array.from(collection_5), Option_fromValueWithDefault(empty(), map$2((f_5) => f_5(table_6)(i_6), commentGetters)));
+    const components = map$1((collection_6) => Array.from(collection_6), Option_fromValueWithDefault(empty(), map$2((f_6) => f_6(table_6)(i_6), componentGetters)));
+    const id = LDLabProcess.genId(processNameRoot, unwrap(assayName), unwrap(studyName)) + `_${i_6}`;
+    let protocol;
+    const name = map$1((f_7) => f_7(table_6)(i_6), protocolREFGetter);
+    const protocolId = LDLabProtocol.genId(unwrap(name), processNameRoot);
+    protocol = LDLabProtocol.create(protocolId, unwrap(name), unwrap(map$1((f_8) => f_8(table_6)(i_6), protocolDescriptionGetter)), unwrap(map$1((f_9) => f_9(table_6)(i_6), protocolTypeGetter)), void 0, void 0, unwrap(components), void 0, unwrap(map$1((f_10) => f_10(table_6)(i_6), protocolURIGetter)), unwrap(map$1((f_11) => f_11(table_6)(i_6), protocolVersionGetter)));
+    const matchValue_2 = inputGetter_1(table_6)(i_6);
+    const matchValue_3 = outputGetter_1(table_6)(i_6);
+    const agent = map$1((f_12) => f_12(table_6)(i_6), performerGetter);
+    return LDLabProcess.create(pn, matchValue_2, matchValue_3, id, unwrap(agent), unwrap(protocol), unwrap(paramvalues), void 0, unwrap(comments));
+  };
+}
+function ProcessConversion_groupProcesses_Z27F0B586(processes, graph, context) {
+  return List_groupBy((p) => {
+    let protocol, protocol_1;
+    const matchValue = LDLabProcess.tryGetNameAsString(p, unwrap(context));
+    const matchValue_1 = LDLabProcess.tryGetExecutesLabProtocol(p, unwrap(graph), unwrap(context));
+    let matchResult, name_1, protocol_2, name_2, protocol_3;
+    if (matchValue != null) {
+      if (ProcessConversion_decomposeProcessName_Z721C83C5(value(matchValue))[1] != null) {
+        matchResult = 0;
+        name_1 = value(matchValue);
+      } else if (matchValue_1 != null) {
+        if (protocol = value(matchValue_1), LDLabProtocol.tryGetNameAsString(protocol, unwrap(context)) != null) {
+          matchResult = 1;
+          protocol_2 = value(matchValue_1);
+        } else {
+          matchResult = 2;
+          name_2 = value(matchValue);
+        }
+      } else {
+        matchResult = 2;
+        name_2 = value(matchValue);
+      }
+    } else if (matchValue_1 != null) {
+      if (protocol_1 = value(matchValue_1), LDLabProtocol.tryGetNameAsString(protocol_1, unwrap(context)) != null) {
+        matchResult = 1;
+        protocol_2 = value(matchValue_1);
+      } else {
+        matchResult = 3;
+        protocol_3 = value(matchValue_1);
+      }
+    } else {
+      matchResult = 4;
+    }
+    switch (matchResult) {
+      case 0:
+        return ProcessConversion_decomposeProcessName_Z721C83C5(name_1)[0];
+      case 1:
+        return defaultArg(LDLabProtocol.tryGetNameAsString(protocol_2, unwrap(context)), "");
+      case 2:
+        return name_2;
+      case 3:
+        return protocol_3.Id;
+      default:
+        return createMissingIdentifier();
+    }
+  }, processes, {
+    Equals: (x, y) => x === y,
+    GetHashCode: stringHash
+  });
+}
+function ProcessConversion_processToRows_Z6839B9E8(p, graph, context) {
+  const pvs = ResizeArray_map((ppv) => [BaseTypes_decomposeParameterValue_Z2F770004(ppv, unwrap(context)), tryGetIndex(ppv)], LDLabProcess.getParameterValues(p, unwrap(graph), unwrap(context)));
+  let components;
+  const matchValue = LDLabProcess.tryGetExecutesLabProtocol(p, unwrap(graph), unwrap(context));
+  if (matchValue == null) {
+    components = [];
+  } else {
+    const prot = value(matchValue);
+    components = ResizeArray_map((ppv_1) => [BaseTypes_decomposeComponent_Z2F770004(ppv_1, unwrap(context)), tryGetIndex(ppv_1)], LDLabProtocol.getComponents(prot, unwrap(graph), unwrap(context)));
+  }
+  let protVals;
+  const matchValue_1 = LDLabProcess.tryGetExecutesLabProtocol(p, unwrap(graph), unwrap(context));
+  if (matchValue_1 == null) {
+    protVals = empty();
+  } else {
+    const prot_1 = value(matchValue_1);
+    protVals = toList(delay(() => {
+      let matchValue_2;
+      return append((matchValue_2 = LDLabProtocol.tryGetNameAsString(prot_1, unwrap(context)), matchValue_2 == null ? empty$1() : singleton([CompositeHeader_ProtocolREF(), CompositeCell_FreeText(value(matchValue_2))])), delay(() => {
+        let matchValue_3;
+        return append((matchValue_3 = LDLabProtocol.tryGetDescriptionAsString(prot_1, unwrap(context)), matchValue_3 == null ? empty$1() : singleton([CompositeHeader_ProtocolDescription(), CompositeCell_FreeText(value(matchValue_3))])), delay(() => {
+          let matchValue_4;
+          return append((matchValue_4 = LDLabProtocol.tryGetUrl(prot_1, unwrap(context)), matchValue_4 == null ? empty$1() : singleton([CompositeHeader_ProtocolUri(), CompositeCell_FreeText(value(matchValue_4))])), delay(() => {
+            let matchValue_5;
+            return append((matchValue_5 = LDLabProtocol.tryGetVersionAsString(prot_1, unwrap(context)), matchValue_5 == null ? empty$1() : singleton([CompositeHeader_ProtocolVersion(), CompositeCell_FreeText(value(matchValue_5))])), delay(() => {
+              const matchValue_6 = ProcessConversion_tryGetProtocolType_Z6839B9E8(prot_1, unwrap(graph), unwrap(context));
+              if (matchValue_6 == null) {
+                return empty$1();
+              } else {
+                return singleton([CompositeHeader_ProtocolType(), CompositeCell_Term(value(matchValue_6))]);
+              }
+            }));
+          }));
+        }));
+      }));
+    }));
+  }
+  const comments = ResizeArray_map((c) => {
+    const c_1 = Comment$.fromString(c);
+    return [CompositeHeader_Comment(defaultArg(c_1.Name, "")), CompositeCell_FreeText(defaultArg(c_1.Value, ""))];
+  }, LDLabProcess.getDisambiguatingDescriptionsAsString(p, unwrap(context)));
+  const inputs = LDLabProcess.getObjects(p, unwrap(graph), unwrap(context));
+  const outputs = LDLabProcess.getResults(p, unwrap(graph), unwrap(context));
+  const patternInput = inputs.length === 0 && outputs.length !== 0 ? [ResizeArray_create(outputs.length, void 0), ResizeArray_map((Value) => Value, outputs)] : inputs.length !== 0 && outputs.length === 0 ? [ResizeArray_map((Value_1) => Value_1, inputs), ResizeArray_create(inputs.length, void 0)] : [ResizeArray_map((Value_2) => Value_2, inputs), ResizeArray_map((Value_3) => Value_3, outputs)];
+  const outputs_1 = patternInput[1];
+  const inputs_1 = patternInput[0];
+  if (inputs_1.length === 0 && outputs_1.length === 0) {
+    const vals = map$2((tuple_1) => tuple_1[0], sortBy((arg) => defaultArg(arg[1], 1e4), toList(delay(() => append(components, delay(() => pvs)))), {
+      Compare: comparePrimitives
+    }));
+    return ResizeArray_singleton(toList(delay(() => append(protVals, delay(() => append(vals, delay(() => comments)))))));
+  } else {
+    return ResizeArray_map((tupledArg) => {
+      const i = tupledArg[0];
+      const o = tupledArg[1];
+      let chars;
+      if (i == null) {
+        chars = [];
+      } else {
+        const i_1 = value(i);
+        chars = ResizeArray_map((cv) => [BaseTypes_decomposeCharacteristicValue_Z2F770004(cv, unwrap(context)), tryGetIndex(cv)], LDSample.getCharacteristics(i_1, unwrap(graph), unwrap(context)));
+      }
+      let factors;
+      if (o == null) {
+        factors = [];
+      } else {
+        const o_1 = value(o);
+        factors = ResizeArray_map((fv) => [BaseTypes_decomposeFactorValue_Z2F770004(fv, unwrap(context)), tryGetIndex(fv)], LDSample.getFactors(o_1, unwrap(graph), unwrap(context)));
+      }
+      const vals_1 = map$2((tuple_3) => tuple_3[0], sortBy((arg_1) => defaultArg(arg_1[1], 1e4), toList(delay(() => append(chars, delay(() => append(components, delay(() => append(pvs, delay(() => factors)))))))), {
+        Compare: comparePrimitives
+      }));
+      return toList(delay(() => append(i != null ? singleton(BaseTypes_decomposeProcessInput_Z2F770004(value(i), unwrap(context))) : empty$1(), delay(() => append(protVals, delay(() => append(vals_1, delay(() => append(comments, delay(() => o != null ? singleton(BaseTypes_decomposeProcessOutput_Z2F770004(value(o), unwrap(context))) : empty$1()))))))))));
+    }, ResizeArray_zip(inputs_1, outputs_1));
+  }
+}
+
+export { ProcessConversion, ProcessConversion_$reflection, ProcessConversion_composeProcessName, ProcessConversion_decomposeProcessName_Z721C83C5, ProcessConversion_getProcessGetter, ProcessConversion_groupProcesses_Z27F0B586, ProcessConversion_processToRows_Z6839B9E8, ProcessConversion_tryCharacteristicGetter, ProcessConversion_tryComponentGetter, ProcessConversion_tryFactorGetter, ProcessConversion_tryGetCommentGetter, ProcessConversion_tryGetInputGetter, ProcessConversion_tryGetOutputGetter, ProcessConversion_tryGetPerformerGetter, ProcessConversion_tryGetProtocolDescriptionGetter, ProcessConversion_tryGetProtocolREFGetter, ProcessConversion_tryGetProtocolTypeGetter, ProcessConversion_tryGetProtocolType_Z6839B9E8, ProcessConversion_tryGetProtocolURIGetter, ProcessConversion_tryGetProtocolVersionGetter, ProcessConversion_tryParameterGetter };

package/dist/ts/ts/Conversion/Run.d.ts

@@ -0,0 +1,35 @@
+import { TypeInfo } from '@fable-org/fable-library-js/Reflection.js';
+import { CWLType_$union } from '../CWL/CWLTypes.js';
+import { CWLInput } from '../CWL/Inputs.js';
+import { CWLParameterReference } from '../CWL/ParameterReference.js';
+import { LDGraph, LDNode } from '../ROCrate/LDObject.js';
+import { LDContext } from '../ROCrate/LDContext.js';
+import { CWLProcessingUnit_$union } from '../CWL/CWLProcessingUnit.js';
+import { ArcRun } from '../Core/ArcTypes.js';
+import { FileSystem } from '../FileSystem/FileSystem.js';
+export declare class RunConversion {
+    constructor();
+}
+export declare function RunConversion_$reflection(): TypeInfo;
+/**
+ * Helper function to format CWLType for display in error messages
+ */
+export declare function RunConversion_formatCWLType_Z5C31A0F9(type_: CWLType_$union): string;
+/**
+ * Helper function to check if a CWLType is or contains an Array type
+ */
+export declare function RunConversion_isArrayType_Z5C31A0F9(type_: CWLType_$union): boolean;
+/**
+ * File paths in CWL files are relative to the file itself. In RO-Crate, we use relative paths from the root of the crate.
+ *
+ * This function replaces the relative paths in the CWL input file with paths relative to the root of the crate.
+ */
+export declare function RunConversion_composeCWLInputFilePath_Z384F8060(path: string, runName: string): string;
+export declare function RunConversion_decomposeCWLInputFilePath_Z384F8060(path: string, runName: string): string;
+export declare function RunConversion_composeCWLInputValue_70DD9184(inputValue: CWLParameterReference, exampleOfWork: LDNode, inputParam: CWLInput, runName: string): LDNode;
+export declare function RunConversion_decomposeCWLInputValue_Z1346FE9D(inputValue: LDNode, runName: string, context?: LDContext, graph?: LDGraph): CWLParameterReference;
+export declare function RunConversion_composeWorkflowInvocationFromArcRun_Z8CC08AC(run: ArcRun, fs?: FileSystem): LDNode[];
+export declare function RunConversion_decomposeMainWorkflowInvocation_Z1346FE9D(workflowInvocation: LDNode, runName: string, context?: LDContext, graph?: LDGraph): [CWLProcessingUnit_$union, CWLParameterReference[]];
+export declare function RunConversion_composeRun_Z8CC08AC(run: ArcRun, fs?: FileSystem): LDNode;
+export declare function RunConversion_decomposeRun_Z6839B9E8(run: LDNode, graph?: LDGraph, context?: LDContext): ArcRun;
+//# sourceMappingURL=Run.d.ts.map

package/dist/ts/ts/Conversion/Run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Run.d.ts","sourceRoot":"","sources":["../../../../src/ARCtrl/ts/Conversion/Run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAEjF,OAAO,EAAgB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAOlE,OAAO,EAAE,QAAQ,EAAgB,MAAM,kBAAkB,CAAC;AAI1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAQvE,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAczD,qBAAa,aAAa;;CAGzB;AAED,wBAAgB,yBAAyB,IAAI,QAAQ,CAEpD;AAED;;GAEG;AACH,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAGnF;AAED;;GAEG;AACH,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAgBlF;AAED;;;;GAIG;AACH,wBAAgB,+CAA+C,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAOrG;AAED,wBAAgB,iDAAiD,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAQvG;AAED,wBAAgB,2CAA2C,CAAC,UAAU,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAwCnK;AAED,wBAAgB,8CAA8C,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAqB/J;AAED,wBAAgB,0DAA0D,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,CAkDjH;AAED,wBAAgB,uDAAuD,CAAC,kBAAkB,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,CAAC,wBAAwB,EAAE,qBAAqB,EAAE,CAAC,CAK9M;AAED,wBAAgB,iCAAiC,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CA8BtF;AAED,wBAAgB,oCAAoC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAoC9G"}