@nfdi4plants/arctrl 3.0.0-beta.9 → 3.0.0

package/dist/ts/ts/Conversion/Basic.js

@@ -0,0 +1,452 @@
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { value, unwrap, map, defaultArg, bind } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDComment } from '../ROCrate/LDTypes/Comment.js';
+import { Comment$ } from '../Core/Comment.js';
+import { LDRef, LDNode } from '../ROCrate/LDObject.js';
+import { OntologyAnnotation } from '../Core/OntologyAnnotation.js';
+import { Option_fromValueWithDefault, Option_fromSeq, ResizeArray_map } from '../Core/Helper/Collections.js';
+import { LDDefinedTerm } from '../ROCrate/LDTypes/DefinedTerm.js';
+import { LDPropertyValue } from '../ROCrate/LDTypes/PropertyValue.js';
+import { Data } from '../Core/Data.js';
+import { CompositeCell_Term, CompositeCell_Unitized, CompositeCell_FreeText, CompositeCell_Data } from '../Core/Table/CompositeCell.js';
+import { toFail, printf } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { CompositeHeader_Component, CompositeHeader_Parameter, CompositeHeader_Factor, CompositeHeader_Characteristic, CompositeHeader_Input, IOType_Source, IOType_Material, IOType_Sample, IOType_Data, IOType_FreeText, CompositeHeader_Output } from '../Core/Table/CompositeHeader.js';
+import { DataFile__get_AsString, DataFile_fromString_Z721C83C5 } from '../Core/DataFile.js';
+import { LDFile } from '../ROCrate/LDTypes/File.js';
+import { LDDataset } from '../ROCrate/LDTypes/Dataset.js';
+import { map as map$1 } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+import { combine } from '../FileSystem/Path.js';
+import { DataContext__get_Explication, DataContext__get_Unit, DataContext__get_ObjectType, DataContext__get_GeneratedBy, DataContext__get_Description, DataContext__get_Label, DataContext_$ctor_Z780A8A2A } from '../Core/DataContext.js';
+import { toString } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { LDSample } from '../ROCrate/LDTypes/Sample.js';
+import { Value_Name, Value_Ontology } from '../Core/Value.js';
+import { ActivePatterns_$007CRegex$007C_$007C } from '../Core/Helper/Regex.js';
+
+class BaseTypes {
+  constructor() {
+  }
+}
+function BaseTypes_$reflection() {
+  return class_type("ARCtrl.Conversion.BaseTypes", void 0, BaseTypes);
+}
+function BaseTypes_composeComment_Z13201A7E(comment) {
+  let name;
+  const matchValue = comment.Name;
+  if (matchValue == null) {
+    throw new Error("Comment must have a name");
+  } else {
+    name = value(matchValue);
+  }
+  return LDComment.create(name, void 0, unwrap(comment.Value));
+}
+function BaseTypes_decomposeComment_Z2F770004(comment, context) {
+  return new Comment$(LDComment.getNameAsString(comment, unwrap(context)), unwrap(LDComment.tryGetTextAsString(comment, unwrap(context))));
+}
+function BaseTypes_ontologyTermFromNameAndID_40457300(name, id) {
+  if (id == null) {
+    return OntologyAnnotation.create(unwrap(name));
+  } else {
+    const t = value(id);
+    return OntologyAnnotation.fromTermAnnotation(t, unwrap(name));
+  }
+}
+function BaseTypes_tryOntologyTermFromNameAndID_40457300(name, id) {
+  if (name == null && id == null) {
+    return void 0;
+  } else {
+    return BaseTypes_ontologyTermFromNameAndID_40457300(unwrap(name), unwrap(id));
+  }
+}
+function BaseTypes_composeDefinedTerm_ZDED3A0F(term) {
+  const tan = Option_fromValueWithDefault("", term.TermAccessionAndOntobeeUrlIfShort);
+  return LDDefinedTerm.create(term.NameText, void 0, unwrap(tan));
+}
+function BaseTypes_decomposeDefinedTerm_Z2F770004(term, context) {
+  return BaseTypes_ontologyTermFromNameAndID_40457300(LDDefinedTerm.getNameAsString(term, unwrap(context)), unwrap(LDDefinedTerm.tryGetTermCodeAsString(term, unwrap(context))));
+}
+function BaseTypes_composePropertyValueFromOA_ZDED3A0F(term) {
+  const tan = Option_fromValueWithDefault("", term.TermAccessionAndOntobeeUrlIfShort);
+  return LDPropertyValue.create(term.NameText, void 0, void 0, unwrap(tan));
+}
+function BaseTypes_decomposePropertyValueToOA_Z2F770004(term, context) {
+  return BaseTypes_ontologyTermFromNameAndID_40457300(LDPropertyValue.getNameAsString(term, unwrap(context)), unwrap(LDPropertyValue.tryGetPropertyIDAsString(term, unwrap(context))));
+}
+function BaseTypes_valuesOfCell_Z436420FE(value) {
+  let term, term_1;
+  switch (value.tag) {
+    case /* Term */
+    0:
+      if (term = value.fields[0], term.isEmpty()) {
+        const term_2 = value.fields[0];
+        return [void 0, void 0, void 0, void 0];
+      } else if (term_1 = value.fields[0], term_1.TANInfo != null) {
+        const term_3 = value.fields[0];
+        return [term_3.Name, term_3.TermAccessionAndOntobeeUrlIfShort, void 0, void 0];
+      } else {
+        const term_4 = value.fields[0];
+        return [term_4.Name, void 0, void 0, void 0];
+      }
+    case /* Unitized */
+    2: {
+      const text_1 = value.fields[0];
+      const unit = value.fields[1];
+      const patternInput = unit.isEmpty() ? [void 0, void 0] : [unit.Name, Option_fromValueWithDefault("", unit.TermAccessionAndOntobeeUrlIfShort)];
+      return [Option_fromValueWithDefault("", text_1), void 0, patternInput[0], patternInput[1]];
+    }
+    case /* Data */
+    3: {
+      const data = 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, void 0, void 0];
+      } else {
+        const text = value.fields[0];
+        return [text, void 0, void 0, void 0];
+      }
+  }
+}
+function BaseTypes_termOfHeader_6CAF647B(header) {
+  let matchResult, oa;
+  switch (header.tag) {
+    case /* Component */
+    0: {
+      matchResult = 0;
+      oa = header.fields[0];
+      break;
+    }
+    case /* Parameter */
+    3: {
+      matchResult = 0;
+      oa = header.fields[0];
+      break;
+    }
+    case /* Factor */
+    2: {
+      matchResult = 0;
+      oa = header.fields[0];
+      break;
+    }
+    case /* Characteristic */
+    1: {
+      matchResult = 0;
+      oa = header.fields[0];
+      break;
+    }
+    default:
+      matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return [oa.NameText, oa.TANInfo != null ? oa.TermAccessionAndOntobeeUrlIfShort : void 0];
+    default:
+      return toFail(printf("header %O should not be parsed to isa value"))(header);
+  }
+}
+function BaseTypes_composeComponent(header, value) {
+  const patternInput = BaseTypes_valuesOfCell_Z436420FE(value);
+  const patternInput_1 = BaseTypes_termOfHeader_6CAF647B(header);
+  return LDPropertyValue.createComponent(patternInput_1[0], unwrap(patternInput[0]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+function BaseTypes_composeParameterValue(header, value) {
+  const patternInput = BaseTypes_valuesOfCell_Z436420FE(value);
+  const patternInput_1 = BaseTypes_termOfHeader_6CAF647B(header);
+  return LDPropertyValue.createParameterValue(patternInput_1[0], unwrap(patternInput[0]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+function BaseTypes_composeFactorValue(header, value) {
+  const patternInput = BaseTypes_valuesOfCell_Z436420FE(value);
+  const patternInput_1 = BaseTypes_termOfHeader_6CAF647B(header);
+  return LDPropertyValue.createFactorValue(patternInput_1[0], unwrap(patternInput[0]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+function BaseTypes_composeCharacteristicValue(header, value) {
+  const patternInput = BaseTypes_valuesOfCell_Z436420FE(value);
+  const patternInput_1 = BaseTypes_termOfHeader_6CAF647B(header);
+  return LDPropertyValue.createCharacteristicValue(patternInput_1[0], unwrap(patternInput[0]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput[3]), unwrap(patternInput[2]), unwrap(patternInput[1]));
+}
+function BaseTypes_composeFreetextMaterialName(headerFT, name) {
+  return `${headerFT}=${name}`;
+}
+function BaseTypes_composeFile_6CE21C7D(d, fs) {
+  const createFile = () => {
+    const dataType = map(DataFile__get_AsString, d.DataType);
+    return LDFile.create(d.NameText, d.NameText, void 0, unwrap(dataType), unwrap(d.Format), unwrap(d.SelectorFormat));
+  };
+  if (fs == null) {
+    return createFile();
+  } else {
+    const fs_1 = value(fs);
+    const matchValue = fs_1.Tree.TryGetPath(d.NameText);
+    if (matchValue != null) {
+      if (value(matchValue).tag === /* Folder */
+      1) {
+        const fs_2 = value(matchValue);
+        const file = createFile();
+        file.SchemaType = [LDFile.schemaType, LDDataset.schemaType];
+        let subFiles;
+        const collection = map$1((fp) => {
+          const fullPath = combine(d.NameText, fp);
+          return LDFile.create(fullPath, fullPath);
+        }, fs_2.ToFilePaths(true));
+        subFiles = Array.from(collection);
+        LDDataset.setHasParts(file, subFiles);
+        return file;
+      } else {
+        return createFile();
+      }
+    } else {
+      return createFile();
+    }
+  }
+}
+function BaseTypes_decomposeFile_Z2F770004(f, context) {
+  const dataType = map(DataFile_fromString_Z721C83C5, LDFile.tryGetDisambiguatingDescriptionAsString(f, unwrap(context)));
+  const format = LDFile.tryGetEncodingFormatAsString(f, unwrap(context));
+  const selectorFormat = LDFile.tryGetUsageInfoAsString(f, unwrap(context));
+  return new Data(void 0, LDFile.getNameAsString(f, unwrap(context)), unwrap(dataType), unwrap(format), unwrap(selectorFormat));
+}
+function BaseTypes_composeFragmentDescriptor_Z4C0BEF62(dc) {
+  if (dc.Name == null) {
+    throw new Error("RO-Crate parsing of DataContext failed: Cannot create a fragment descriptor without a name.");
+  }
+  const id = LDPropertyValue.genIdFragmentDescriptor(dc.NameText);
+  const patternInput = defaultArg(map((e) => [e.Name, Option_fromValueWithDefault("", e.TermAccessionAndOntobeeUrlIfShort)], DataContext__get_Explication(dc)), [void 0, void 0]);
+  const patternInput_1 = defaultArg(map((u) => [u.Name, Option_fromValueWithDefault("", u.TermAccessionAndOntobeeUrlIfShort)], DataContext__get_Unit(dc)), [void 0, void 0]);
+  const disambiguatingDescriptions = Option_fromSeq(ResizeArray_map(toString, dc.Comments));
+  const dataFragment = BaseTypes_composeFile_6CE21C7D(dc);
+  const pattern = map(BaseTypes_composeDefinedTerm_ZDED3A0F, DataContext__get_ObjectType(dc));
+  dataFragment.SetProperty(LDFile.about, new LDRef(id));
+  dataFragment.SetOptionalProperty(LDFile.pattern, pattern);
+  return LDPropertyValue.createFragmentDescriptor(dc.NameText, unwrap(patternInput[0]), void 0, unwrap(patternInput_1[1]), unwrap(patternInput_1[0]), unwrap(patternInput[1]), unwrap(DataContext__get_GeneratedBy(dc)), unwrap(DataContext__get_Description(dc)), unwrap(DataContext__get_Label(dc)), unwrap(disambiguatingDescriptions), dataFragment);
+}
+function BaseTypes_decomposeFragmentDescriptor_Z6839B9E8(fd, graph, context) {
+  const file = LDPropertyValue.tryGetSubjectOf(fd, unwrap(graph), unwrap(context));
+  let name;
+  if (file == null) {
+    throw new Error("RO-Crate parsing of DataContext failed: Cannot decompose a fragment descriptor without a name.");
+  } else {
+    const f = value(file);
+    name = LDFile.getNameAsString(f, unwrap(context));
+  }
+  const objectType = map((pa) => BaseTypes_decomposeDefinedTerm_Z2F770004(pa, unwrap(context)), bind((f_1) => LDFile.tryGetPatternAsDefinedTerm(f_1, unwrap(graph), unwrap(context)), file));
+  const format = bind((f_2) => LDFile.tryGetEncodingFormatAsString(f_2, unwrap(context)), file);
+  const selectorFormat = bind((f_3) => LDFile.tryGetUsageInfoAsString(f_3, unwrap(context)), file);
+  const explication = BaseTypes_tryOntologyTermFromNameAndID_40457300(unwrap(LDPropertyValue.tryGetValueAsString(fd)), unwrap(LDPropertyValue.tryGetValueReferenceAsString(fd)));
+  const unit = BaseTypes_tryOntologyTermFromNameAndID_40457300(unwrap(LDPropertyValue.tryGetUnitTextAsString(fd)), unwrap(LDPropertyValue.tryGetUnitCodeAsString(fd)));
+  const generatedBy = LDPropertyValue.tryGetMeasurementMethodAsString(fd);
+  const description = LDPropertyValue.tryGetDescriptionAsString(fd);
+  return DataContext_$ctor_Z780A8A2A(void 0, name, void 0, unwrap(format), unwrap(selectorFormat), unwrap(explication), unwrap(unit), unwrap(objectType), unwrap(LDPropertyValue.tryGetAlternateNameAsString(fd)), unwrap(description), unwrap(generatedBy), ResizeArray_map((s) => Comment$.fromString(s), LDPropertyValue.getDisambiguatingDescriptionsAsString(fd)));
+}
+function BaseTypes_composeProcessInput(header, value, fs) {
+  if (header.tag === /* Input */
+  11) {
+    switch (header.fields[0].tag) {
+      case /* Sample */
+      1:
+        return LDSample.createSample(value.AsFreeText);
+      case /* Material */
+      3:
+        return LDSample.createMaterial(value.AsFreeText);
+      case /* Data */
+      2:
+        switch (value.tag) {
+          case /* FreeText */
+          1: {
+            const ft = value.fields[0];
+            return LDFile.create(ft, ft);
+          }
+          case /* Data */
+          3:
+            return BaseTypes_composeFile_6CE21C7D(value.fields[0], unwrap(fs));
+          default:
+            return toFail(printf("Could not parse input data %O"))(value);
+        }
+      case /* FreeText */
+      4: {
+        const ft_1 = header.fields[0].fields[0];
+        const n = new LDNode(BaseTypes_composeFreetextMaterialName(ft_1, value.AsFreeText), [ft_1]);
+        n.SetProperty(LDSample.name, value.AsFreeText);
+        return n;
+      }
+      default:
+        return LDSample.createSource(value.AsFreeText);
+    }
+  } else {
+    return toFail(printf("Could not parse input header %O"))(header);
+  }
+}
+function BaseTypes_composeProcessOutput(header, value, fs) {
+  let matchResult, ft_1;
+  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_1 = header.fields[0].fields[0];
+        break;
+      }
+      default:
+        matchResult = 0;
+    }
+  } else {
+    matchResult = 4;
+  }
+  switch (matchResult) {
+    case 0:
+      return LDSample.createSample(value.AsFreeText);
+    case 1:
+      return LDSample.createMaterial(value.AsFreeText);
+    case 2:
+      switch (value.tag) {
+        case /* FreeText */
+        1: {
+          const ft = value.fields[0];
+          return LDFile.create(ft, ft);
+        }
+        case /* Data */
+        3:
+          return BaseTypes_composeFile_6CE21C7D(value.fields[0], unwrap(fs));
+        default:
+          return toFail(printf("Could not parse output data %O"))(value);
+      }
+    case 3: {
+      const n = new LDNode(BaseTypes_composeFreetextMaterialName(ft_1, value.AsFreeText), [ft_1]);
+      n.SetProperty(LDSample.name, value.AsFreeText);
+      return n;
+    }
+    default:
+      return toFail(printf("Could not parse output header %O"))(header);
+  }
+}
+function BaseTypes_headerOntologyOfPropertyValue_Z2F770004(pv, context) {
+  const n = LDPropertyValue.getNameAsString(pv, unwrap(context));
+  const matchValue = LDPropertyValue.tryGetPropertyIDAsString(pv, unwrap(context));
+  if (matchValue == null) {
+    return new OntologyAnnotation(n);
+  } else {
+    const nRef = value(matchValue);
+    return OntologyAnnotation.fromTermAnnotation(nRef, n);
+  }
+}
+function BaseTypes_cellOfPropertyValue_Z2F770004(pv, context) {
+  const v = LDPropertyValue.tryGetValueAsString(pv, unwrap(context));
+  const vRef = LDPropertyValue.tryGetValueReferenceAsString(pv, unwrap(context));
+  const u = LDPropertyValue.tryGetUnitTextAsString(pv, unwrap(context));
+  const uRef = LDPropertyValue.tryGetUnitCodeAsString(pv, unwrap(context));
+  let matchResult, vr, u_1, uRef_1;
+  if (vRef == null) {
+    if (u == null) {
+      if (uRef == null) {
+        matchResult = 3;
+      } else {
+        matchResult = 2;
+        uRef_1 = value(uRef);
+      }
+    } else if (uRef != null) {
+      matchResult = 2;
+      uRef_1 = value(uRef);
+    } else {
+      matchResult = 1;
+      u_1 = value(u);
+    }
+  } else if (u == null) {
+    if (uRef == null) {
+      matchResult = 0;
+      vr = value(vRef);
+    } else {
+      matchResult = 4;
+    }
+  } else {
+    matchResult = 4;
+  }
+  switch (matchResult) {
+    case 0:
+      return CompositeCell_Term(OntologyAnnotation.fromTermAnnotation(vr, unwrap(v)));
+    case 1:
+      return CompositeCell_Unitized(defaultArg(v, ""), new OntologyAnnotation(u_1));
+    case 2:
+      return CompositeCell_Unitized(defaultArg(v, ""), OntologyAnnotation.fromTermAnnotation(uRef_1, unwrap(u)));
+    case 3:
+      return CompositeCell_Term(new OntologyAnnotation(unwrap(v)));
+    default: {
+      const arg = defaultArg(v, "");
+      return toFail(printf("Could not parse value %s with unit %O and unit reference %O"))(arg)(u)(uRef);
+    }
+  }
+}
+function BaseTypes_decomposePropertyValue_Z2F770004(pv, context) {
+  let v, vRef, vr, u, uRef, uRef_1, u_1;
+  return [BaseTypes_headerOntologyOfPropertyValue_Z2F770004(pv, unwrap(context)), (v = LDPropertyValue.tryGetValueAsString(pv, unwrap(context)), vRef = LDPropertyValue.tryGetValueReferenceAsString(pv, unwrap(context)), vRef == null ? v == null ? void 0 : Value_Name(value(v)) : (vr = value(vRef), Value_Ontology(OntologyAnnotation.fromTermAnnotation(vr, unwrap(v))))), (u = LDPropertyValue.tryGetUnitTextAsString(pv, unwrap(context)), uRef = LDPropertyValue.tryGetUnitCodeAsString(pv, unwrap(context)), u == null ? uRef == null ? void 0 : (uRef_1 = value(uRef), OntologyAnnotation.fromTermAnnotation(uRef_1, unwrap(u))) : uRef != null ? (uRef_1 = value(uRef), OntologyAnnotation.fromTermAnnotation(uRef_1, unwrap(u))) : (u_1 = value(u), new OntologyAnnotation(u_1)))];
+}
+function BaseTypes_decomposeComponent_Z2F770004(c, context) {
+  return [CompositeHeader_Component(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+function BaseTypes_decomposeParameterValue_Z2F770004(c, context) {
+  return [CompositeHeader_Parameter(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+function BaseTypes_decomposeFactorValue_Z2F770004(c, context) {
+  return [CompositeHeader_Factor(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+function BaseTypes_decomposeCharacteristicValue_Z2F770004(c, context) {
+  return [CompositeHeader_Characteristic(BaseTypes_headerOntologyOfPropertyValue_Z2F770004(c, unwrap(context))), BaseTypes_cellOfPropertyValue_Z2F770004(c, unwrap(context))];
+}
+function BaseTypes_decomposeProcessInput_Z2F770004(pn, context) {
+  if (LDSample.validateSource(pn, unwrap(context))) {
+    return [CompositeHeader_Input(IOType_Source()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+  } else if (LDSample.validateMaterial(pn, unwrap(context))) {
+    return [CompositeHeader_Input(IOType_Material()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+  } else if (LDSample.validate(pn, unwrap(context))) {
+    return [CompositeHeader_Input(IOType_Sample()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+  } else if (LDFile.validate(pn, unwrap(context))) {
+    return [CompositeHeader_Input(IOType_Data()), CompositeCell_Data(BaseTypes_decomposeFile_Z2F770004(pn, unwrap(context)))];
+  } else {
+    const n = pn;
+    return [CompositeHeader_Input(IOType_FreeText(n.SchemaType[0])), CompositeCell_FreeText(LDSample.getNameAsString(n, unwrap(context)))];
+  }
+}
+function BaseTypes_decomposeProcessOutput_Z2F770004(pn, context) {
+  if (LDSample.validateMaterial(pn, unwrap(context))) {
+    return [CompositeHeader_Output(IOType_Material()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+  } else if (LDSample.validate(pn, unwrap(context))) {
+    return [CompositeHeader_Output(IOType_Sample()), CompositeCell_FreeText(LDSample.getNameAsString(pn, unwrap(context)))];
+  } else if (LDFile.validate(pn, unwrap(context))) {
+    return [CompositeHeader_Output(IOType_Data()), CompositeCell_Data(BaseTypes_decomposeFile_Z2F770004(pn, unwrap(context)))];
+  } else {
+    const n = pn;
+    return [CompositeHeader_Output(IOType_FreeText(n.SchemaType[0])), CompositeCell_FreeText(LDSample.getNameAsString(n, unwrap(context)))];
+  }
+}
+function BaseTypes_composeTechnologyPlatform_ZDED3A0F(tp) {
+  const matchValue = tp.TANInfo;
+  if (matchValue == null) {
+    return `${tp.NameText}`;
+  } else {
+    return `${tp.NameText} (${tp.TermAccessionShort})`;
+  }
+}
+function BaseTypes_decomposeTechnologyPlatform_Z721C83C5(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);
+  }
+}
+
+export { BaseTypes, BaseTypes_$reflection, BaseTypes_cellOfPropertyValue_Z2F770004, BaseTypes_composeCharacteristicValue, BaseTypes_composeComment_Z13201A7E, BaseTypes_composeComponent, BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_composeFactorValue, BaseTypes_composeFile_6CE21C7D, BaseTypes_composeFragmentDescriptor_Z4C0BEF62, BaseTypes_composeFreetextMaterialName, BaseTypes_composeParameterValue, BaseTypes_composeProcessInput, BaseTypes_composeProcessOutput, BaseTypes_composePropertyValueFromOA_ZDED3A0F, BaseTypes_composeTechnologyPlatform_ZDED3A0F, BaseTypes_decomposeCharacteristicValue_Z2F770004, BaseTypes_decomposeComment_Z2F770004, BaseTypes_decomposeComponent_Z2F770004, BaseTypes_decomposeDefinedTerm_Z2F770004, BaseTypes_decomposeFactorValue_Z2F770004, BaseTypes_decomposeFile_Z2F770004, BaseTypes_decomposeFragmentDescriptor_Z6839B9E8, BaseTypes_decomposeParameterValue_Z2F770004, BaseTypes_decomposeProcessInput_Z2F770004, BaseTypes_decomposeProcessOutput_Z2F770004, BaseTypes_decomposePropertyValueToOA_Z2F770004, BaseTypes_decomposePropertyValue_Z2F770004, BaseTypes_decomposeTechnologyPlatform_Z721C83C5, BaseTypes_headerOntologyOfPropertyValue_Z2F770004, BaseTypes_ontologyTermFromNameAndID_40457300, BaseTypes_termOfHeader_6CAF647B, BaseTypes_tryOntologyTermFromNameAndID_40457300, BaseTypes_valuesOfCell_Z436420FE };

package/dist/ts/ts/Conversion/ColumnIndex.d.ts

@@ -0,0 +1,11 @@
+import { int32 } from '@fable-org/fable-library-js/Int32.js';
+import { Option } from '@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../ROCrate/LDObject.js';
+export declare const orderName = "columnIndex";
+export declare const columndIndexProperty = "https://w3id.org/ro/terms/arc#columnIndex";
+export declare function tryGetIndex(node: LDNode): Option<int32>;
+export declare function setIndex(node: LDNode, index: int32): void;
+export declare function ARCtrl_ROCrate_LDNode__LDNode_GetColumnIndex(this$: LDNode): int32;
+export declare function ARCtrl_ROCrate_LDNode__LDNode_TryGetColumnIndex(this$: LDNode): Option<int32>;
+export declare function ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(this$: LDNode, index: int32): void;
+//# sourceMappingURL=ColumnIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ColumnIndex.d.ts","sourceRoot":"","sources":["../../../../src/ARCtrl/ts/Conversion/ColumnIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,EAAE,MAAM,sCAAsC,CAAC;AAEvE,OAAO,EAAS,MAAM,EAAE,MAAM,uCAAuC,CAAC;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAiBhD,eAAO,MAAM,SAAS,gBAAgB,CAAC;AAEvC,eAAO,MAAM,oBAAoB,8CAA8C,CAAC;AAEhF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAyCvD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAEzD;AAED,wBAAgB,4CAA4C,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAEjF;AAED,wBAAgB,+CAA+C,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAE5F;AAED,wBAAgB,sDAAsD,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAExG"}

package/dist/ts/ts/Conversion/ColumnIndex.js

@@ -0,0 +1,71 @@
+import { tryParse } from '../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { FSharpRef } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { value } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { int32ToString } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+
+function tryInt(str) {
+  let matchValue;
+  let outArg = 0;
+  matchValue = [tryParse(str, 511, false, 32, new FSharpRef(() => outArg, (v) => {
+    outArg = v | 0;
+  })), outArg];
+  if (matchValue[0]) {
+    return matchValue[1];
+  } else {
+    return void 0;
+  }
+}
+const orderName = "columnIndex";
+const columndIndexProperty = "https://w3id.org/ro/terms/arc#columnIndex";
+function tryGetIndex(node) {
+  const matchValue = node.TryGetPropertyAsSingleton(columndIndexProperty);
+  let matchResult, ci;
+  if (matchValue != null) {
+    if (typeof value(matchValue) === "string") {
+      matchResult = 0;
+      ci = value(matchValue);
+    } else {
+      matchResult = 1;
+    }
+  } else {
+    matchResult = 1;
+  }
+  switch (matchResult) {
+    case 0:
+      return tryInt(ci);
+    default: {
+      const matchValue_1 = node.TryGetPropertyAsSingleton(orderName);
+      let matchResult_1, ci_1;
+      if (matchValue_1 != null) {
+        if (typeof value(matchValue_1) === "string") {
+          matchResult_1 = 0;
+          ci_1 = value(matchValue_1);
+        } else {
+          matchResult_1 = 1;
+        }
+      } else {
+        matchResult_1 = 1;
+      }
+      switch (matchResult_1) {
+        case 0:
+          return tryInt(ci_1);
+        default:
+          return void 0;
+      }
+    }
+  }
+}
+function setIndex(node, index) {
+  node.SetProperty(columndIndexProperty, int32ToString(index));
+}
+function ARCtrl_ROCrate_LDNode__LDNode_GetColumnIndex(this$) {
+  return value(tryGetIndex(this$));
+}
+function ARCtrl_ROCrate_LDNode__LDNode_TryGetColumnIndex(this$) {
+  return tryGetIndex(this$);
+}
+function ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4(this$, index) {
+  setIndex(this$, index);
+}
+
+export { ARCtrl_ROCrate_LDNode__LDNode_GetColumnIndex, ARCtrl_ROCrate_LDNode__LDNode_SetColumnIndex_Z524259A4, ARCtrl_ROCrate_LDNode__LDNode_TryGetColumnIndex, columndIndexProperty, orderName, setIndex, tryGetIndex };

package/dist/ts/ts/Conversion/Datamap.d.ts

@@ -0,0 +1,11 @@
+import { TypeInfo } from '@fable-org/fable-library-js/Reflection.js';
+import { LDGraph, LDNode } from '../ROCrate/LDObject.js';
+import { Datamap } from '../Core/Datamap.js';
+import { LDContext } from '../ROCrate/LDContext.js';
+export declare class DatamapConversion {
+    constructor();
+}
+export declare function DatamapConversion_$reflection(): TypeInfo;
+export declare function DatamapConversion_composeFragmentDescriptors_Z892BFC3(datamap: Datamap): LDNode[];
+export declare function DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(fragmentDescriptors: LDNode[], graph?: LDGraph, context?: LDContext): Datamap;
+//# sourceMappingURL=Datamap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Datamap.d.ts","sourceRoot":"","sources":["../../../../src/ARCtrl/ts/Conversion/Datamap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAIjF,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,qBAAa,iBAAiB;;CAG7B;AAED,wBAAgB,6BAA6B,IAAI,QAAQ,CAExD;AAED,wBAAgB,qDAAqD,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAEhG;AAED,wBAAgB,wDAAwD,CAAC,mBAAmB,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO,CAErJ"}

package/dist/ts/ts/Conversion/Datamap.js

@@ -0,0 +1,21 @@
+import { class_type } from '../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { ResizeArray_map } from '../Core/Helper/Collections.js';
+import { BaseTypes_composeFragmentDescriptor_Z4C0BEF62, BaseTypes_decomposeFragmentDescriptor_Z6839B9E8 } from './Basic.js';
+import { Datamap } from '../Core/Datamap.js';
+import { unwrap } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+
+class DatamapConversion {
+  constructor() {
+  }
+}
+function DatamapConversion_$reflection() {
+  return class_type("ARCtrl.Conversion.DatamapConversion", void 0, DatamapConversion);
+}
+function DatamapConversion_composeFragmentDescriptors_Z892BFC3(datamap) {
+  return ResizeArray_map(BaseTypes_composeFragmentDescriptor_Z4C0BEF62, datamap.DataContexts);
+}
+function DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(fragmentDescriptors, graph, context) {
+  return new Datamap(ResizeArray_map((fd) => BaseTypes_decomposeFragmentDescriptor_Z6839B9E8(fd, unwrap(graph), unwrap(context)), fragmentDescriptors));
+}
+
+export { DatamapConversion, DatamapConversion_$reflection, DatamapConversion_composeFragmentDescriptors_Z892BFC3, DatamapConversion_decomposeFragmentDescriptors_Z6E59645F };

package/dist/ts/ts/Conversion/DateTime.d.ts

@@ -0,0 +1,4 @@
+import { Option } from '@fable-org/fable-library-js/Option.js';
+export declare function tryFromString(s: string): Option<Date>;
+export declare function toString(d: Date): string;
+//# sourceMappingURL=DateTime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DateTime.d.ts","sourceRoot":"","sources":["../../../../src/ARCtrl/ts/Conversion/DateTime.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAI/D,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAWrD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAExC"}

package/dist/ts/ts/Conversion/DateTime.js

@@ -0,0 +1,23 @@
+import { fromString } from '../fable_modules/Thoth.Json.JavaScript.0.4.1/Decode.fs.js';
+import { Decode_datetime } from '../Json/Decode.js';
+import { toText, printf } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { toString as toString$1 } from '../fable_modules/Thoth.Json.JavaScript.0.4.1/Encode.fs.js';
+import { dateTime } from '../Json/Encode.js';
+
+function tryFromString(s) {
+  let matchValue;
+  try {
+    return matchValue = fromString(Decode_datetime, s), matchValue.tag === /* Error */
+    1 ? (() => {
+      let arg;
+      throw new Error((arg = matchValue.fields[0], toText(printf("Error decoding string: %O"))(arg)));
+    })() : matchValue.fields[0];
+  } catch (matchValue_1) {
+    return void 0;
+  }
+}
+function toString(d) {
+  return toString$1(0, dateTime(d));
+}
+
+export { toString, tryFromString };

package/dist/ts/ts/Conversion/Investigation.d.ts

@@ -0,0 +1,12 @@
+import { TypeInfo } from '@fable-org/fable-library-js/Reflection.js';
+import { LDGraph, LDNode } from '../ROCrate/LDObject.js';
+import { ArcInvestigation } from '../Core/ArcTypes.js';
+import { FileSystem } from '../FileSystem/FileSystem.js';
+import { LDContext } from '../ROCrate/LDContext.js';
+export declare class InvestigationConversion {
+    constructor();
+}
+export declare function InvestigationConversion_$reflection(): TypeInfo;
+export declare function InvestigationConversion_composeInvestigation_Z284BC0AC(investigation: ArcInvestigation, fs?: FileSystem, ignoreBrokenWR?: boolean): LDNode;
+export declare function InvestigationConversion_decomposeInvestigation_Z6839B9E8(investigation: LDNode, graph?: LDGraph, context?: LDContext): ArcInvestigation;
+//# sourceMappingURL=Investigation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Investigation.d.ts","sourceRoot":"","sources":["../../../../src/ARCtrl/ts/Conversion/Investigation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAOjF,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAOzD,OAAO,EAAE,gBAAgB,EAA2C,MAAM,qBAAqB,CAAC;AAKhG,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,qBAAa,uBAAuB;;CAGnC;AAED,wBAAgB,mCAAmC,IAAI,QAAQ,CAE9D;AAED,wBAAgB,sDAAsD,CAAC,aAAa,EAAE,gBAAgB,EAAE,EAAE,CAAC,EAAE,UAAU,EAAE,cAAc,CAAC,EAAE,OAAO,GAAG,MAAM,CA0CzJ;AAED,wBAAgB,wDAAwD,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,gBAAgB,CAetJ"}