@nfdi4plants/arctrl 3.0.0-beta.9 → 3.0.0

package/dist/ts/ts/Conversion/Run.js

@@ -0,0 +1,254 @@
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { writeYaml, encodeCWLType } from '../CWL/Encode.js';
+import { CWLType_file } from '../CWL/CWLTypes.js';
+import { exists, tryPick, find } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { replace, trimStart, join, toFail, printf } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { combineMany, combine } from '../FileSystem/Path.js';
+import { value, defaultArg, bind, unwrap, map } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { equals } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { LDFile } from '../ROCrate/LDTypes/File.js';
+import { LDPropertyValue } from '../ROCrate/LDTypes/PropertyValue.js';
+import { ResizeArray_singleton, ResizeArray_map, ResizeArray_zip, ResizeArray_appendSingleton, Option_fromSeq, Option_fromValueWithDefault, ResizeArray_filter } from '../Core/Helper/Collections.js';
+import { CWLParameterReference } from '../CWL/ParameterReference.js';
+import { LDFormalParameter } from '../ROCrate/LDTypes/FormalParameter.js';
+import { Run_cwlFileNameFromIdentifier } from '../Core/Helper/Identifier.js';
+import { WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7, WorkflowConversion_getInputParametersFromProcessingUnit_30922B92, WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F } from './Workflow.js';
+import { LDComputationalWorkflow } from '../ROCrate/LDTypes/ComputationalWorkflow.js';
+import { ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C, ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586 } from './Table.js';
+import { ArcTables } from '../Core/Table/ArcTables.js';
+import { ofSeq } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { LDWorkflowInvocation } from '../ROCrate/LDTypes/WorkflowInvocation.js';
+import { LDLabProcess } from '../ROCrate/LDTypes/LabProcess.js';
+import { ArcRun } from '../Core/ArcTypes.js';
+import { BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_composePropertyValueFromOA_ZDED3A0F, BaseTypes_composeComment_Z13201A7E, BaseTypes_decomposeDefinedTerm_Z2F770004, BaseTypes_decomposePropertyValueToOA_Z2F770004, BaseTypes_decomposeComment_Z2F770004 } from './Basic.js';
+import { PersonConversion_composePerson_Z64D846DC, PersonConversion_decomposePerson_Z6839B9E8 } from './Person.js';
+import { LDOrganization } from '../ROCrate/LDTypes/Organization.js';
+import { utcNow } from '../../node_modules/@fable-org/fable-library-js/Date.js';
+import { DatamapConversion_composeFragmentDescriptors_Z892BFC3, DatamapConversion_decomposeFragmentDescriptors_Z6E59645F } from './Datamap.js';
+import { Datamap } from '../Core/Datamap.js';
+import { AssayConversion_getDataFilesFromProcesses_6BABD1B0 } from './Assay.js';
+import { LDDataset } from '../ROCrate/LDTypes/Dataset.js';
+import { LDWorkflowProtocol } from '../ROCrate/LDTypes/WorkflowProtocol.js';
+
+class RunConversion {
+  constructor() {
+  }
+}
+function RunConversion_$reflection() {
+  return class_type("ARCtrl.Conversion.RunConversion", void 0, RunConversion);
+}
+function RunConversion_formatCWLType_Z5C31A0F9(type_) {
+  const s = writeYaml(encodeCWLType(type_));
+  return s.trim();
+}
+function RunConversion_isArrayType_Z5C31A0F9(type_) {
+  switch (type_.tag) {
+    case /* Array */
+    11:
+      return true;
+    case /* Union */
+    14:
+      return exists((_arg) => {
+        if (_arg.tag === /* Array */
+        11) {
+          return true;
+        } else {
+          return false;
+        }
+      }, type_.fields[0]);
+    default:
+      return false;
+  }
+}
+function RunConversion_composeCWLInputFilePath_Z384F8060(path, runName) {
+  if (path.startsWith("../..")) {
+    return replace(replace(path, "../../", ""), "../..", "");
+  } else {
+    return combineMany(["runs", runName, path]);
+  }
+}
+function RunConversion_decomposeCWLInputFilePath_Z384F8060(path, runName) {
+  const prefix = combineMany(["runs", runName]);
+  if (path.startsWith(prefix)) {
+    return trimStart(replace(path, prefix, ""), "/");
+  } else {
+    return combine("../..", path);
+  }
+}
+function RunConversion_composeCWLInputValue_70DD9184(inputValue, exampleOfWork, inputParam, runName) {
+  if (inputParam.Type_ == null) {
+    throw new Error(`Cannot convert param values "${inputValue.Values}" as Input parameter "${inputParam.Name}" has no type.`);
+  }
+  const type_ = value(inputParam.Type_);
+  if (inputValue.Type != null) {
+    if (!equals(value(inputValue.Type), type_)) {
+      throw new Error(`Type (${RunConversion_formatCWLType_Z5C31A0F9(value(inputValue.Type))}) of yml input value "${inputValue.Key}" does not match type of workflow input parameter (${RunConversion_formatCWLType_Z5C31A0F9(type_)}).`);
+    }
+  }
+  let matchResult;
+  if (type_.tag === /* File */
+  0) {
+    if (inputValue.Values.length === 1) {
+      matchResult = 0;
+    } else if (RunConversion_isArrayType_Z5C31A0F9(type_)) {
+      matchResult = 1;
+    } else {
+      matchResult = 2;
+    }
+  } else if (RunConversion_isArrayType_Z5C31A0F9(type_)) {
+    matchResult = 1;
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0: {
+      const path = RunConversion_composeCWLInputFilePath_Z384F8060(inputValue.Values[0], runName);
+      return LDFile.createCWLParameter(path, exampleOfWork);
+    }
+    case 1: {
+      const values = join(defaultArg(bind((ib) => ib.ItemSeparator, inputParam.InputBinding), ","), inputValue.Values);
+      return LDPropertyValue.createCWLParameter(exampleOfWork, inputValue.Key, ResizeArray_singleton(values));
+    }
+    default:
+      return LDPropertyValue.createCWLParameter(exampleOfWork, inputValue.Key, inputValue.Values);
+  }
+}
+function RunConversion_decomposeCWLInputValue_Z1346FE9D(inputValue, runName, context, graph) {
+  let exampleOfWork;
+  const matchValue = LDFile.tryGetExampleOfWorkAsFormalParameter(inputValue, unwrap(graph), unwrap(context));
+  if (matchValue == null) {
+    const arg = inputValue.Id;
+    exampleOfWork = toFail(printf("Input value %s of run %s must have an exampleOfWork property pointing to a CWL formal parameter."))(arg)(runName);
+  } else {
+    exampleOfWork = value(matchValue);
+  }
+  const key = LDFormalParameter.getNameAsString(exampleOfWork, unwrap(context));
+  if (LDFile.validateCWLParameter(inputValue, unwrap(context))) {
+    return new CWLParameterReference(key, [RunConversion_decomposeCWLInputFilePath_Z384F8060(inputValue.Id, runName)], CWLType_file());
+  } else if (LDPropertyValue.validateCWLParameter(inputValue, unwrap(context))) {
+    return new CWLParameterReference(key, LDPropertyValue.getValuesAsString(inputValue, unwrap(context)));
+  } else {
+    const arg_2 = inputValue.Id;
+    return toFail(printf("Input value %s of run %s is neither a CWL File nor a CWL Parameter."))(arg_2)(runName);
+  }
+}
+function RunConversion_composeWorkflowInvocationFromArcRun_Z8CC08AC(run, fs) {
+  let b;
+  let workflowProtocol;
+  const workflowFilePath = Run_cwlFileNameFromIdentifier(run.Identifier);
+  const matchValue = run.CWLDescription;
+  if (matchValue == null) {
+    const arg = run.Identifier;
+    workflowProtocol = toFail(printf("Run %s must have a CWL description"))(arg);
+  } else {
+    workflowProtocol = WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7(workflowFilePath, value(matchValue), void 0, run.Identifier);
+  }
+  const inputParams = ResizeArray_map((tupledArg) => {
+    const ldI = tupledArg[1];
+    const name = LDFormalParameter.getNameAsString(ldI, unwrap(workflowProtocol.TryGetContext()));
+    const paramRef = tryPick((i_1) => {
+      if (i_1.Key === name) {
+        return i_1;
+      } else {
+        return void 0;
+      }
+    }, run.CWLInput);
+    if (paramRef == null) {
+      throw new Error(`Could not create workflow invocation for run "${run.Identifier}": Workflow parameter "${name}" had no assigned value.`);
+    } else {
+      return RunConversion_composeCWLInputValue_70DD9184(value(paramRef), ldI, tupledArg[0], run.Identifier);
+    }
+  }, (b = LDComputationalWorkflow.getInputsAsFormalParameters(workflowProtocol, void 0, unwrap(workflowProtocol.TryGetContext())), ResizeArray_zip(WorkflowConversion_getInputParametersFromProcessingUnit_30922B92(value(run.CWLDescription)), b)));
+  let processSequence;
+  const collection = ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C(new ArcTables(run.Tables), void 0, void 0, unwrap(fs));
+  processSequence = Array.from(collection);
+  const mainInvocation = LDWorkflowInvocation.create(run.Identifier, workflowProtocol, inputParams, void 0, void 0, void 0, void 0, void 0, void 0, workflowProtocol);
+  if (processSequence.length === 0) {
+    return ResizeArray_singleton(mainInvocation);
+  } else {
+    return ResizeArray_appendSingleton(mainInvocation, ResizeArray_map((p) => {
+      const id = replace(p.Id, "Process", `WorkflowInvocation_${run.Identifier}`);
+      const name_1 = LDLabProcess.getNameAsString(p, unwrap(p.TryGetContext()));
+      const inputs = LDLabProcess.getObjects(p);
+      const results = Option_fromSeq(LDLabProcess.getResults(p));
+      const protocol = LDLabProcess.tryGetExecutesLabProtocol(p);
+      const parameterValues = Option_fromSeq(LDLabProcess.getParameterValues(p));
+      const agents = map(ResizeArray_singleton, LDLabProcess.tryGetAgent(p));
+      const disambiguatingDescriptions = Option_fromSeq(LDLabProcess.getDisambiguatingDescriptionsAsString(p));
+      return LDWorkflowInvocation.create(name_1, workflowProtocol, inputs, unwrap(results), void 0, unwrap(agents), id, void 0, unwrap(disambiguatingDescriptions), unwrap(protocol), unwrap(parameterValues));
+    }, processSequence));
+  }
+}
+function RunConversion_decomposeMainWorkflowInvocation_Z1346FE9D(workflowInvocation, runName, context, graph) {
+  let matchValue;
+  return [(matchValue = LDLabProcess.tryGetExecutesLabProtocol(workflowInvocation, unwrap(graph), unwrap(context)), matchValue == null ? (() => {
+    throw new Error(`Could not decompose workflow invocation for run "${runName}": Workflow parameter "name" had no assigned value.`);
+  })() : WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F(value(matchValue), void 0, unwrap(context), unwrap(graph))), ResizeArray_map((iv) => RunConversion_decomposeCWLInputValue_Z1346FE9D(iv, runName, unwrap(context), unwrap(graph)), LDLabProcess.getObjects(workflowInvocation, unwrap(graph), unwrap(context)))];
+}
+function RunConversion_composeRun_Z8CC08AC(run, fs) {
+  let fds_1, vm_1, fds, vm;
+  let workflowProtocol;
+  const workflowFilePath = Run_cwlFileNameFromIdentifier(run.Identifier);
+  const matchValue = run.CWLDescription;
+  if (matchValue == null) {
+    const arg = run.Identifier;
+    workflowProtocol = toFail(printf("Run %s must have a CWL description"))(arg);
+  } else {
+    workflowProtocol = WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7(workflowFilePath, value(matchValue), void 0, run.Identifier);
+  }
+  const workflowInvocations = Option_fromSeq(RunConversion_composeWorkflowInvocationFromArcRun_Z8CC08AC(run, unwrap(fs)));
+  const measurementMethod = map(BaseTypes_composeDefinedTerm_ZDED3A0F, run.TechnologyType);
+  const measurementTechnique = map(BaseTypes_composeDefinedTerm_ZDED3A0F, run.TechnologyPlatform);
+  const variableMeasured = map(BaseTypes_composePropertyValueFromOA_ZDED3A0F, run.MeasurementType);
+  const creators = Option_fromSeq(ResizeArray_map(PersonConversion_composePerson_Z64D846DC, run.Performers));
+  const publisher = LDOrganization.create("DataPLANT");
+  const dateCreated = utcNow();
+  if (creators != null) {
+    LDComputationalWorkflow.setCreators(workflowProtocol, value(creators));
+  }
+  LDComputationalWorkflow.setSdPublisher(workflowProtocol, publisher);
+  LDComputationalWorkflow.setDateCreatedAsDateTime(workflowProtocol, dateCreated);
+  const fragmentDescriptors = map(DatamapConversion_composeFragmentDescriptors_Z892BFC3, run.Datamap);
+  const dataFiles = map((ps) => AssayConversion_getDataFilesFromProcesses_6BABD1B0(ps, unwrap(fragmentDescriptors)), workflowInvocations);
+  const hasParts = dataFiles == null ? ResizeArray_singleton(workflowProtocol) : ResizeArray_appendSingleton(workflowProtocol, value(dataFiles));
+  const variableMeasureds = variableMeasured == null ? fragmentDescriptors == null ? void 0 : (fds_1 = value(fragmentDescriptors), fds_1) : fragmentDescriptors == null ? (vm_1 = value(variableMeasured), ResizeArray_singleton(vm_1)) : (fds = value(fragmentDescriptors), vm = value(variableMeasured), ResizeArray_appendSingleton(vm, fds));
+  const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, run.Comments));
+  return LDDataset.createARCRun(run.Identifier, ResizeArray_singleton(workflowProtocol), void 0, unwrap(run.Title), unwrap(run.Description), unwrap(creators), unwrap(hasParts), unwrap(measurementMethod), unwrap(measurementTechnique), unwrap(variableMeasureds), unwrap(workflowInvocations), unwrap(workflowInvocations), unwrap(comments));
+}
+function RunConversion_decomposeRun_Z6839B9E8(run, graph, context) {
+  const workflowProtocol = LDDataset.tryGetMainEntityAsWorkflowProtocol(run, unwrap(graph), unwrap(context));
+  const mainWorkflowInvocation = find((wi) => {
+    let lp;
+    const matchValue = LDLabProcess.tryGetExecutesLabProtocol(wi, unwrap(graph), unwrap(context));
+    let matchResult, lp_1;
+    if (matchValue != null) {
+      if (lp = value(matchValue), LDWorkflowProtocol.validate(lp, unwrap(context))) {
+        matchResult = 0;
+        lp_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return true;
+      default:
+        return false;
+    }
+  }, LDDataset.getAboutsAsWorkflowInvocation(run, unwrap(graph), unwrap(context)));
+  const patternInput = workflowProtocol == null ? RunConversion_decomposeMainWorkflowInvocation_Z1346FE9D(mainWorkflowInvocation, LDDataset.getIdentifierAsString(run, unwrap(context)), unwrap(context), unwrap(graph)) : [WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F(value(workflowProtocol), void 0, unwrap(context), unwrap(graph)), ResizeArray_map((iv) => RunConversion_decomposeCWLInputValue_Z1346FE9D(iv, LDDataset.getIdentifierAsString(run, unwrap(context)), unwrap(context), unwrap(graph)), LDLabProcess.getObjects(mainWorkflowInvocation, unwrap(graph), unwrap(context)))];
+  const measurementMethod = map((m) => BaseTypes_decomposeDefinedTerm_Z2F770004(m, unwrap(context)), LDDataset.tryGetMeasurementMethodAsDefinedTerm(run, unwrap(graph), unwrap(context)));
+  const measurementTechnique = map((m_1) => BaseTypes_decomposeDefinedTerm_Z2F770004(m_1, unwrap(context)), LDDataset.tryGetMeasurementTechniqueAsDefinedTerm(run, unwrap(graph), unwrap(context)));
+  const variableMeasured = map((v) => BaseTypes_decomposePropertyValueToOA_Z2F770004(v, unwrap(context)), LDDataset.tryGetVariableMeasuredAsMeasurementType(run, unwrap(graph), unwrap(context)));
+  const contacts = ResizeArray_map((c) => PersonConversion_decomposePerson_Z6839B9E8(c, unwrap(graph), unwrap(context)), LDDataset.getCreators(run, unwrap(graph), unwrap(context)));
+  const comments = ResizeArray_map((c_1) => BaseTypes_decomposeComment_Z2F770004(c_1, unwrap(context)), LDDataset.getComments(run, unwrap(graph), unwrap(context)));
+  let datamap;
+  const v_1 = DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(LDDataset.getVariableMeasuredAsFragmentDescriptors(run, unwrap(graph), unwrap(context)), unwrap(graph), unwrap(context));
+  datamap = Option_fromValueWithDefault(Datamap.init(), v_1);
+  const tables = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(ofSeq(ResizeArray_filter((wi_1) => wi_1.Id !== mainWorkflowInvocation.Id, LDDataset.getAboutsAsLabProcess(run, unwrap(graph), unwrap(context)))), unwrap(graph), unwrap(context));
+  return ArcRun.create(LDDataset.getIdentifierAsString(run, unwrap(context)), unwrap(LDDataset.tryGetNameAsString(run, unwrap(context))), unwrap(LDDataset.tryGetDescriptionAsString(run, unwrap(context))), unwrap(variableMeasured), unwrap(measurementMethod), unwrap(measurementTechnique), void 0, tables.Tables, unwrap(datamap), contacts, patternInput[0], patternInput[1], comments);
+}
+
+export { RunConversion, RunConversion_$reflection, RunConversion_composeCWLInputFilePath_Z384F8060, RunConversion_composeCWLInputValue_70DD9184, RunConversion_composeRun_Z8CC08AC, RunConversion_composeWorkflowInvocationFromArcRun_Z8CC08AC, RunConversion_decomposeCWLInputFilePath_Z384F8060, RunConversion_decomposeCWLInputValue_Z1346FE9D, RunConversion_decomposeMainWorkflowInvocation_Z1346FE9D, RunConversion_decomposeRun_Z6839B9E8, RunConversion_formatCWLType_Z5C31A0F9, RunConversion_isArrayType_Z5C31A0F9 };

package/dist/ts/ts/Conversion/ScholarlyArticle.d.ts

@@ -0,0 +1,16 @@
+import { TypeInfo } from '@fable-org/fable-library-js/Reflection.js';
+import { LDGraph, LDNode } from '../ROCrate/LDObject.js';
+import { LDContext } from '../ROCrate/LDContext.js';
+import { Publication } from '../Core/Publication.js';
+export declare class ScholarlyArticleConversion {
+    constructor();
+}
+export declare function ScholarlyArticleConversion_$reflection(): TypeInfo;
+export declare function ScholarlyArticleConversion_composeAuthor_Z721C83C5(author: string): LDNode;
+export declare function ScholarlyArticleConversion_splitAuthors_Z721C83C5(a: string): string[];
+export declare function ScholarlyArticleConversion_composeAuthors_Z721C83C5(authors: string): LDNode[];
+export declare function ScholarlyArticleConversion_decomposeAuthor_Z2F770004(author: LDNode, context?: LDContext): string;
+export declare function ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5(authors: LDNode[], context?: LDContext): string;
+export declare function ScholarlyArticleConversion_composeScholarlyArticle_D324A6D(publication: Publication): LDNode;
+export declare function ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(sa: LDNode, graph?: LDGraph, context?: LDContext): Publication;
+//# sourceMappingURL=ScholarlyArticle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScholarlyArticle.d.ts","sourceRoot":"","sources":["../../../../src/ARCtrl/ts/Conversion/ScholarlyArticle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAIjF,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AASzD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAOpD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,qBAAa,0BAA0B;;CAGtC;AAED,wBAAgB,sCAAsC,IAAI,QAAQ,CAEjE;AAED,wBAAgB,kDAAkD,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAczF;AAED,wBAAgB,iDAAiD,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAmCrF;AAED,wBAAgB,mDAAmD,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAG7F;AAED,wBAAgB,oDAAoD,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAOhH;AAED,wBAAgB,oDAAoD,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,CAEnH;AAED,wBAAgB,0DAA0D,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAc3G;AAED,wBAAgB,8DAA8D,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,WAAW,CAa5I"}

package/dist/ts/ts/Conversion/ScholarlyArticle.js

@@ -0,0 +1,116 @@
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { LDPerson } from '../ROCrate/LDTypes/Person.js';
+import { fromString } from '../fable_modules/Thoth.Json.JavaScript.0.4.1/Decode.fs.js';
+import { decoder, encoder } from '../Json/ROCrate/LDNode.js';
+import { toText, printf, join } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { StringBuilder_$ctor, StringBuilder__Clear, StringBuilder__Append_244C7CD6 } from '../../node_modules/@fable-org/fable-library-js/System.Text.js';
+import { getEnumerator, disposeSafe } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { toString } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { map, isEmpty, filter, toList, delay, append, singleton, empty } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { unwrap, value, map as map$1 } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { toString as toString$1 } from '../fable_modules/Thoth.Json.JavaScript.0.4.1/Encode.fs.js';
+import { ResizeArray_map, Option_fromSeq, ResizeArray_tryPick } from '../Core/Helper/Collections.js';
+import { BaseTypes_composeComment_Z13201A7E, BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_decomposeComment_Z2F770004, BaseTypes_decomposeDefinedTerm_Z2F770004 } from './Basic.js';
+import { LDPropertyValue } from '../ROCrate/LDTypes/PropertyValue.js';
+import { LDScholarlyArticle } from '../ROCrate/LDTypes/ScholarlyArticle.js';
+import { Publication } from '../Core/Publication.js';
+
+class ScholarlyArticleConversion {
+  constructor() {
+  }
+}
+function ScholarlyArticleConversion_$reflection() {
+  return class_type("ARCtrl.Conversion.ScholarlyArticleConversion", void 0, ScholarlyArticleConversion);
+}
+function ScholarlyArticleConversion_composeAuthor_Z721C83C5(author) {
+  let arg;
+  try {
+    const matchValue = fromString(decoder, author);
+    if (matchValue.tag === /* Error */
+    1) {
+      throw new Error((arg = matchValue.fields[0], toText(printf("Error decoding string: %O"))(arg)));
+    } else {
+      return matchValue.fields[0];
+    }
+  } catch (matchValue_1) {
+    return LDPerson.create(author);
+  }
+}
+function ScholarlyArticleConversion_splitAuthors_Z721C83C5(a) {
+  let bracketCount = 0;
+  const authors = [];
+  const sb = StringBuilder_$ctor();
+  const enumerator = getEnumerator(a.split(""));
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const c = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      switch (c) {
+        case "{": {
+          bracketCount = bracketCount + 1 | 0;
+          StringBuilder__Append_244C7CD6(sb, c);
+          break;
+        }
+        case "}": {
+          bracketCount = bracketCount - 1 | 0;
+          StringBuilder__Append_244C7CD6(sb, c);
+          break;
+        }
+        default:
+          if (c === "," && bracketCount === 0) {
+            void authors.push(toString(sb));
+            StringBuilder__Clear(sb);
+          } else {
+            StringBuilder__Append_244C7CD6(sb, c);
+          }
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  void authors.push(toString(sb));
+  return authors;
+}
+function ScholarlyArticleConversion_composeAuthors_Z721C83C5(authors) {
+  const collection = map(ScholarlyArticleConversion_composeAuthor_Z721C83C5, ScholarlyArticleConversion_splitAuthors_Z721C83C5(authors));
+  return Array.from(collection);
+}
+function ScholarlyArticleConversion_decomposeAuthor_Z2F770004(author, context) {
+  if (isEmpty(filter((n) => n !== LDPerson.givenName, author.GetPropertyNames(unwrap(context))))) {
+    return LDPerson.getGivenNameAsString(author, unwrap(context));
+  } else {
+    return toString$1(0, encoder(author));
+  }
+}
+function ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5(authors, context) {
+  return join(",", ResizeArray_map((a) => ScholarlyArticleConversion_decomposeAuthor_Z2F770004(a, unwrap(context)), authors));
+}
+function ScholarlyArticleConversion_composeScholarlyArticle_D324A6D(publication) {
+  let title;
+  const matchValue = publication.Title;
+  if (matchValue == null) {
+    throw new Error("Publication must have a title");
+  } else {
+    title = value(matchValue);
+  }
+  const authors_1 = map$1(ScholarlyArticleConversion_composeAuthors_Z721C83C5, publication.Authors);
+  const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, publication.Comments));
+  const identifiers = Array.from(toList(delay(() => append(publication.DOI != null && value(publication.DOI) !== "" ? singleton(LDPropertyValue.createDOI(value(publication.DOI))) : empty(), delay(() => publication.PubMedID != null && value(publication.PubMedID) !== "" ? singleton(LDPropertyValue.createPubMedID(value(publication.PubMedID))) : empty())))));
+  const status = map$1(BaseTypes_composeDefinedTerm_ZDED3A0F, publication.Status);
+  return LDScholarlyArticle.create(title, identifiers, void 0, unwrap(authors_1), void 0, unwrap(status), unwrap(comments));
+}
+function ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(sa, graph, context) {
+  const title = LDScholarlyArticle.getHeadlineAsString(sa, unwrap(context));
+  const authors = map$1((a) => ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5(a, unwrap(context)), Option_fromSeq(LDScholarlyArticle.getAuthors(sa, unwrap(graph), unwrap(context))));
+  const comments = ResizeArray_map((c) => BaseTypes_decomposeComment_Z2F770004(c, unwrap(context)), LDScholarlyArticle.getComments(sa, unwrap(graph), unwrap(context)));
+  const status = map$1((s) => BaseTypes_decomposeDefinedTerm_Z2F770004(s, unwrap(context)), LDScholarlyArticle.tryGetCreativeWorkStatus(sa, unwrap(graph), unwrap(context)));
+  const identifiers = LDScholarlyArticle.getIdentifiersAsPropertyValue(sa, unwrap(graph), unwrap(context));
+  let doi;
+  const _arg = ResizeArray_tryPick((i) => LDPropertyValue.tryGetAsDOI(i, unwrap(context)), identifiers);
+  doi = _arg == null ? LDScholarlyArticle.tryGetSameAsAsString(sa, unwrap(context)) : value(_arg);
+  let pubMedID;
+  const _arg_1 = ResizeArray_tryPick((i_1) => LDPropertyValue.tryGetAsPubMedID(i_1, unwrap(context)), identifiers);
+  pubMedID = _arg_1 == null ? LDScholarlyArticle.tryGetUrlAsString(sa, unwrap(context)) : value(_arg_1);
+  return Publication.create(unwrap(pubMedID), unwrap(doi), unwrap(authors), title, unwrap(status), comments);
+}
+
+export { ScholarlyArticleConversion, ScholarlyArticleConversion_$reflection, ScholarlyArticleConversion_composeAuthor_Z721C83C5, ScholarlyArticleConversion_composeAuthors_Z721C83C5, ScholarlyArticleConversion_composeScholarlyArticle_D324A6D, ScholarlyArticleConversion_decomposeAuthor_Z2F770004, ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5, ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8, ScholarlyArticleConversion_splitAuthors_Z721C83C5 };

package/dist/ts/ts/Conversion/Study.d.ts

@@ -0,0 +1,12 @@
+import { TypeInfo } from '@fable-org/fable-library-js/Reflection.js';
+import { LDGraph, LDNode } from '../ROCrate/LDObject.js';
+import { ArcStudy } from '../Core/ArcTypes.js';
+import { FileSystem } from '../FileSystem/FileSystem.js';
+import { LDContext } from '../ROCrate/LDContext.js';
+export declare class StudyConversion {
+    constructor();
+}
+export declare function StudyConversion_$reflection(): TypeInfo;
+export declare function StudyConversion_composeStudy_ZFE0E38E(study: ArcStudy, fs?: FileSystem): LDNode;
+export declare function StudyConversion_decomposeStudy_Z6839B9E8(study: LDNode, graph?: LDGraph, context?: LDContext): ArcStudy;
+//# sourceMappingURL=Study.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Study.d.ts","sourceRoot":"","sources":["../../../../src/ARCtrl/ts/Conversion/Study.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAOjF,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAWzD,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,qBAAa,eAAe;;CAG3B;AAED,wBAAgB,2BAA2B,IAAI,QAAQ,CAEtD;AAED,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,CAY9F;AAED,wBAAgB,wCAAwC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,QAAQ,CAWtH"}

package/dist/ts/ts/Conversion/Study.js

@@ -0,0 +1,51 @@
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { bind, unwrap, map } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { tryFromString, toString } from './DateTime.js';
+import { now } from '../../node_modules/@fable-org/fable-library-js/Date.js';
+import { Option_fromSeq, ResizeArray_map, Option_fromValueWithDefault } from '../Core/Helper/Collections.js';
+import { ScholarlyArticleConversion_composeScholarlyArticle_D324A6D, ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8 } from './ScholarlyArticle.js';
+import { PersonConversion_composePerson_Z64D846DC, PersonConversion_decomposePerson_Z6839B9E8 } from './Person.js';
+import { ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C, ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586 } from './Table.js';
+import { ArcTables } from '../Core/Table/ArcTables.js';
+import { DatamapConversion_composeFragmentDescriptors_Z892BFC3, DatamapConversion_decomposeFragmentDescriptors_Z6E59645F } from './Datamap.js';
+import { Datamap } from '../Core/Datamap.js';
+import { AssayConversion_getDataFilesFromProcesses_6BABD1B0 } from './Assay.js';
+import { BaseTypes_composeComment_Z13201A7E, BaseTypes_decomposeComment_Z2F770004 } from './Basic.js';
+import { LDDataset } from '../ROCrate/LDTypes/Dataset.js';
+import { ArcStudy } from '../Core/ArcTypes.js';
+import { ofSeq } from '../../node_modules/@fable-org/fable-library-js/List.js';
+
+class StudyConversion {
+  constructor() {
+  }
+}
+function StudyConversion_$reflection() {
+  return class_type("ARCtrl.Conversion.StudyConversion", void 0, StudyConversion);
+}
+function StudyConversion_composeStudy_ZFE0E38E(study, fs) {
+  let collection;
+  const dateCreated = bind(tryFromString, study.SubmissionDate);
+  const datePublished = bind(tryFromString, study.PublicReleaseDate);
+  const dateModified = now();
+  const publications = Option_fromSeq(ResizeArray_map(ScholarlyArticleConversion_composeScholarlyArticle_D324A6D, study.Publications));
+  const creators = Option_fromSeq(ResizeArray_map(PersonConversion_composePerson_Z64D846DC, study.Contacts));
+  const processSequence = Option_fromSeq((collection = ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C(new ArcTables(study.Tables), void 0, study.Identifier, unwrap(fs)), Array.from(collection)));
+  const fragmentDescriptors = map(DatamapConversion_composeFragmentDescriptors_Z892BFC3, study.Datamap);
+  const dataFiles = map((ps) => AssayConversion_getDataFilesFromProcesses_6BABD1B0(ps, unwrap(fragmentDescriptors)), processSequence);
+  const comments = Option_fromSeq(ResizeArray_map(BaseTypes_composeComment_Z13201A7E, study.Comments));
+  return LDDataset.createStudy(study.Identifier, void 0, unwrap(creators), unwrap(dateCreated), unwrap(datePublished), dateModified, unwrap(study.Description), unwrap(dataFiles), unwrap(study.Title), unwrap(publications), unwrap(fragmentDescriptors), unwrap(comments), void 0, unwrap(processSequence));
+}
+function StudyConversion_decomposeStudy_Z6839B9E8(study, graph, context) {
+  const dateCreated = map(toString, LDDataset.tryGetDateCreatedAsDateTime(study, unwrap(context)));
+  const datePublished = map(toString, LDDataset.tryGetDatePublishedAsDateTime(study, unwrap(context)));
+  const publications = ResizeArray_map((p) => ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(p, unwrap(graph), unwrap(context)), LDDataset.getCitations(study, unwrap(graph), unwrap(context)));
+  const creators = ResizeArray_map((c) => PersonConversion_decomposePerson_Z6839B9E8(c, unwrap(graph), unwrap(context)), LDDataset.getCreators(study, unwrap(graph), unwrap(context)));
+  let datamap;
+  const v = DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(LDDataset.getVariableMeasuredAsFragmentDescriptors(study, unwrap(graph), unwrap(context)), unwrap(graph), unwrap(context));
+  datamap = Option_fromValueWithDefault(Datamap.init(), v);
+  const tables = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(ofSeq(LDDataset.getAboutsAsLabProcess(study, unwrap(graph), unwrap(context))), unwrap(graph), unwrap(context));
+  const comments = ResizeArray_map((c_1) => BaseTypes_decomposeComment_Z2F770004(c_1, unwrap(context)), LDDataset.getComments(study, unwrap(graph), unwrap(context)));
+  return ArcStudy.create(LDDataset.getIdentifierAsString(study, unwrap(context)), unwrap(LDDataset.tryGetNameAsString(study, unwrap(context))), unwrap(LDDataset.tryGetDescriptionAsString(study, unwrap(context))), unwrap(dateCreated), unwrap(datePublished), publications, creators, void 0, tables.Tables, unwrap(datamap), void 0, comments);
+}
+
+export { StudyConversion, StudyConversion_$reflection, StudyConversion_composeStudy_ZFE0E38E, StudyConversion_decomposeStudy_Z6839B9E8 };

package/dist/ts/ts/Conversion/Table.d.ts

@@ -0,0 +1,45 @@
+import { LDGraph, LDNode } from '../ROCrate/LDObject.js';
+import { CompositeCell_$union } from '../Core/Table/CompositeCell.js';
+import { CompositeHeader_$union } from '../Core/Table/CompositeHeader.js';
+import { Option } from '@fable-org/fable-library-js/Option.js';
+import { ArcTable } from '../Core/Table/ArcTable.js';
+import { LDContext } from '../ROCrate/LDContext.js';
+import { FSharpList } from '@fable-org/fable-library-js/List.js';
+import { FileSystem } from '../FileSystem/FileSystem.js';
+import { ArcTables } from '../Core/Table/ArcTables.js';
+export declare function CompositeRow_toProtocol(tableName: string, row: Iterable<[CompositeHeader_$union, CompositeCell_$union]>): LDNode;
+/**
+ * Create a new table from an ISA protocol.
+ *
+ * The table will have at most one row, with the protocol information and the component values
+ */
+export declare function ARCtrl_ArcTable__ArcTable_fromProtocol_Static_Z6839B9E8(p: LDNode, graph?: LDGraph, context?: LDContext): ArcTable;
+/**
+ * Returns the list of protocols executed in this ArcTable
+ */
+export declare function ARCtrl_ArcTable__ArcTable_GetProtocols(this$: ArcTable): FSharpList<LDNode>;
+/**
+ * Returns the list of processes specidified in this ArcTable
+ */
+export declare function ARCtrl_ArcTable__ArcTable_GetProcesses_5E660E5C(this$: ArcTable, assayName: Option<string>, studyName: Option<string>, fs: Option<FileSystem>): FSharpList<LDNode>;
+/**
+ * Create a new table from a list of processes
+ *
+ * The name will be used as the sheet name
+ *
+ * The processes SHOULD have the same headers, or even execute the same protocol
+ */
+export declare function ARCtrl_ArcTable__ArcTable_fromProcesses_Static_Z3575FB5F(name: string, ps: FSharpList<LDNode>, graph?: LDGraph, context?: LDContext): ArcTable;
+/**
+ * Return a list of all the processes in all the tables.
+ */
+export declare function ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C(this$: ArcTables, assayName: Option<string>, studyName: Option<string>, fs: Option<FileSystem>): FSharpList<LDNode>;
+/**
+ * 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 declare function ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(ps: FSharpList<LDNode>, graph?: LDGraph, context?: LDContext): ArcTables;
+//# sourceMappingURL=Table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Table.d.ts","sourceRoot":"","sources":["../../../../src/ARCtrl/ts/Conversion/Table.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGzD,OAAO,EAAE,oBAAoB,EAAiB,MAAM,gCAAgC,CAAC;AACrF,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,MAAM,EAAe,MAAM,uCAAuC,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAIrD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGpD,OAAO,EAAgC,UAAU,EAAyB,MAAM,qCAAqC,CAAC;AAItH,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAEvD,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,sBAAsB,EAAE,oBAAoB,CAAC,CAAC,GAAG,MAAM,CAkGhI;AAED;;;;GAIG;AACH,wBAAgB,uDAAuD,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,QAAQ,CA4BjI;AAED;;GAEG;AACH,wBAAgB,sCAAsC,CAAC,KAAK,EAAE,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC,CAyB1F;AAED;;GAEG;AACH,wBAAgB,+CAA+C,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAQjL;AAED;;;;;;GAMG;AACH,wBAAgB,wDAAwD,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,QAAQ,CAG7J;AAED;;GAEG;AACH,wBAAgB,iDAAiD,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAEpL;AAED;;;;;;GAMG;AACH,wBAAgB,0DAA0D,CAAC,EAAE,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,SAAS,CAMlJ"}