@nfdi4plants/arctrl 3.0.0-beta.12 → 3.0.0-beta.13

package/dist/ts/ts/CWL/Decode.js

@@ -0,0 +1,649 @@
+import { getEnumerator, disposeSafe } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { YAMLElement_Sequence } from '../fable_modules/YAMLicious.0.0.3/YAMLiciousTypes.fs.js';
+import { setProperty, setOptionalProperty } from '../fable_modules/DynamicObj.7.1.0/DynObj.fs.js';
+import { DynamicObj } from '../fable_modules/DynamicObj.7.1.0/DynamicObj.fs.js';
+import { isEmpty, head, tail, iterate, map, empty, ofArray } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { object, string, bool, map as map$1, resizearray, float, int, read } from '../fable_modules/YAMLicious.0.0.3/Decode.fs.js';
+import { toFail, printf, toText, replace } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { OutputBinding, CWLOutput } from './Outputs.js';
+import { value, some } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { CWLType_Dirent, DirentInstance, CWLType_Array, CWLType_Boolean, CWLType_Double, CWLType_Float, CWLType_Long, CWLType_Int, CWLType_String, CWLType_Directory, DirectoryInstance_$ctor, CWLType_File, FileInstance_$ctor, CWLType_Stdout, CWLType_Null, SoftwarePackage, SchemaDefRequirementType_$ctor_541DA560 } from './CWLTypes.js';
+import { toArray, delay, collect, append, empty as empty$1, singleton, item, length, map as map$2 } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { getItemFromDict } from '../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { FSharpMap__get_Keys, FSharpMap__get_Values } from '../../node_modules/@fable-org/fable-library-js/Map.js';
+import { DockerRequirement, EnvironmentDef, ResourceRequirementInstance_$ctor_D76FC00, Requirement_StepInputExpressionRequirement, Requirement_MultipleInputFeatureRequirement, Requirement_ScatterFeatureRequirement, Requirement_SubworkflowFeatureRequirement, Requirement_ToolTimeLimitRequirement, Requirement_InplaceUpdateRequirement, Requirement_NetworkAccessRequirement, Requirement_WorkReuseRequirement, Requirement_ResourceRequirement, Requirement_ShellCommandRequirement, Requirement_EnvVarRequirement, Requirement_InitialWorkDirRequirement, Requirement_SoftwareRequirement, Requirement_DockerRequirement, Requirement_SchemaDefRequirement, Requirement_InlineJavascriptRequirement } from './Requirements.js';
+import { InputBinding, CWLInput } from './Inputs.js';
+import { StepInput, StepOutput, WorkflowStep } from './WorkflowSteps.js';
+import { CWLToolDescription } from './ToolDescription.js';
+import { CWLWorkflowDescription } from './WorkflowDescription.js';
+import { CWLProcessingUnit_Workflow, CWLProcessingUnit_CommandLineTool } from './CWLProcessingUnit.js';
+import { CWLParameterReference } from './ParameterReference.js';
+
+function ResizeArray_map(f, a) {
+  const b = [];
+  let enumerator = getEnumerator(a);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const i = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      void b.push(f(i));
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return b;
+}
+function Decode_overflowDecoder(dynObj, dict) {
+  let enumerator = getEnumerator(dict);
+  try {
+    while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+      const e = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      const matchValue = e[1];
+      let matchResult, v, s;
+      if (matchValue.tag === /* Object */
+      3) {
+        if (!isEmpty(matchValue.fields[0])) {
+          switch (head(matchValue.fields[0]).tag) {
+            case /* Value */
+            1: {
+              if (isEmpty(tail(matchValue.fields[0]))) {
+                matchResult = 0;
+                v = head(matchValue.fields[0]).fields[0];
+              } else {
+                matchResult = 2;
+              }
+              break;
+            }
+            case /* Sequence */
+            2: {
+              if (isEmpty(tail(matchValue.fields[0]))) {
+                matchResult = 1;
+                s = head(matchValue.fields[0]).fields[0];
+              } else {
+                matchResult = 2;
+              }
+              break;
+            }
+            default:
+              matchResult = 2;
+          }
+        } else {
+          matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+      switch (matchResult) {
+        case 0: {
+          setProperty(e[0], v.Value, dynObj);
+          break;
+        }
+        case 1: {
+          const newDynObj = new DynamicObj();
+          iterate((x) => {
+            setProperty(e[0], x, dynObj);
+          }, map((arg) => Decode_overflowDecoder(newDynObj, object((get$) => get$.Overflow.FieldList(empty()), arg)), s));
+          break;
+        }
+        case 2: {
+          setProperty(e[0], e[1], dynObj);
+          break;
+        }
+      }
+    }
+  } finally {
+    disposeSafe(enumerator);
+  }
+  return dynObj;
+}
+function Decode_decodeStringOrExpression(yEle) {
+  let matchResult, v, c, v_1;
+  switch (yEle.tag) {
+    case /* Value */
+    1: {
+      matchResult = 0;
+      v = yEle.fields[0];
+      break;
+    }
+    case /* Object */
+    3: {
+      if (!isEmpty(yEle.fields[0])) {
+        switch (head(yEle.fields[0]).tag) {
+          case /* Value */
+          1: {
+            if (isEmpty(tail(yEle.fields[0]))) {
+              matchResult = 0;
+              v = head(yEle.fields[0]).fields[0];
+            } else {
+              matchResult = 2;
+            }
+            break;
+          }
+          case /* Mapping */
+          0: {
+            if (head(yEle.fields[0]).fields[1].tag === /* Object */
+            3) {
+              if (!isEmpty(head(yEle.fields[0]).fields[1].fields[0])) {
+                if (head(head(yEle.fields[0]).fields[1].fields[0]).tag === /* Value */
+                1) {
+                  if (isEmpty(tail(head(yEle.fields[0]).fields[1].fields[0]))) {
+                    if (isEmpty(tail(yEle.fields[0]))) {
+                      matchResult = 1;
+                      c = head(yEle.fields[0]).fields[0];
+                      v_1 = head(head(yEle.fields[0]).fields[1].fields[0]).fields[0];
+                    } else {
+                      matchResult = 2;
+                    }
+                  } else {
+                    matchResult = 2;
+                  }
+                } else {
+                  matchResult = 2;
+                }
+              } else {
+                matchResult = 2;
+              }
+            } else {
+              matchResult = 2;
+            }
+            break;
+          }
+          default:
+            matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+      break;
+    }
+    default:
+      matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return v.Value;
+    case 1:
+      return toText(printf("%s: %s"))(c.Value)(v_1.Value);
+    default:
+      return toFail(printf("%A"))(yEle);
+  }
+}
+const Decode_outputBindingGlobDecoder = (value_1) => object((get$) => {
+  let objectArg;
+  return new OutputBinding((objectArg = get$.Optional, objectArg.Field("glob", string)));
+}, value_1);
+const Decode_outputBindingDecoder = (value) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("outputBinding", Decode_outputBindingGlobDecoder);
+}, value);
+const Decode_outputSourceDecoder = (value_1) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("outputSource", string);
+}, value_1);
+const Decode_direntDecoder = (value_1) => object((get$) => {
+  let objectArg, objectArg_1, objectArg_2;
+  return CWLType_Dirent(new DirentInstance((objectArg = get$.Required, objectArg.Field("entry", Decode_decodeStringOrExpression)), (objectArg_1 = get$.Optional, objectArg_1.Field("entryname", Decode_decodeStringOrExpression)), (objectArg_2 = get$.Optional, objectArg_2.Field("writable", bool))));
+}, value_1);
+const Decode_cwlArrayTypeDecoder = (value_1) => object((get$) => {
+  let objectArg_1;
+  let items;
+  const objectArg = get$.Required;
+  items = objectArg.Field("items", string);
+  switch (items) {
+    case "File":
+      return CWLType_Array(CWLType_File(FileInstance_$ctor()));
+    case "Directory":
+      return CWLType_Array(CWLType_Directory(DirectoryInstance_$ctor()));
+    case "Dirent":
+      return CWLType_Array((objectArg_1 = get$.Required, objectArg_1.Field("listing", Decode_direntDecoder)));
+    case "string":
+      return CWLType_Array(CWLType_String());
+    case "int":
+      return CWLType_Array(CWLType_Int());
+    case "long":
+      return CWLType_Array(CWLType_Long());
+    case "float":
+      return CWLType_Array(CWLType_Float());
+    case "double":
+      return CWLType_Array(CWLType_Double());
+    case "boolean":
+      return CWLType_Array(CWLType_Boolean());
+    default:
+      throw new Error("Invalid CWL type");
+  }
+}, value_1);
+function Decode_cwlTypeStringMatcher(t, get$) {
+  let objectArg, objectArg_1;
+  const patternInput = t.endsWith("?") ? [true, replace(t, "?", "")] : [false, t];
+  const newT = patternInput[1];
+  return [newT === "File" ? CWLType_File(FileInstance_$ctor()) : newT === "Directory" ? CWLType_Directory(DirectoryInstance_$ctor()) : newT === "Dirent" ? (objectArg = get$.Required, objectArg.Field("listing", Decode_direntDecoder)) : newT === "string" ? CWLType_String() : newT === "int" ? CWLType_Int() : newT === "long" ? CWLType_Long() : newT === "float" ? CWLType_Float() : newT === "double" ? CWLType_Double() : newT === "boolean" ? CWLType_Boolean() : newT === "File[]" ? CWLType_Array(CWLType_File(FileInstance_$ctor())) : newT === "Directory[]" ? CWLType_Array(CWLType_Directory(DirectoryInstance_$ctor())) : newT === "Dirent[]" ? CWLType_Array((objectArg_1 = get$.Required, objectArg_1.Field("listing", Decode_direntDecoder))) : newT === "string[]" ? CWLType_Array(CWLType_String()) : newT === "int[]" ? CWLType_Array(CWLType_Int()) : newT === "long[]" ? CWLType_Array(CWLType_Long()) : newT === "float[]" ? CWLType_Array(CWLType_Float()) : newT === "double[]" ? CWLType_Array(CWLType_Double()) : newT === "boolean[]" ? CWLType_Array(CWLType_Boolean()) : newT === "stdout" ? CWLType_Stdout() : newT === "null" ? CWLType_Null() : (() => {
+    throw new Error("Invalid CWL type");
+  })(), patternInput[0]];
+}
+const Decode_cwlTypeDecoder = (value_1) => object((get$) => {
+  let objectArg_1;
+  let cwlType;
+  const objectArg = get$.Required;
+  cwlType = objectArg.Field("type", (value) => {
+    let matchResult, v, o;
+    switch (value.tag) {
+      case /* Value */
+      1: {
+        matchResult = 0;
+        v = value.fields[0];
+        break;
+      }
+      case /* Object */
+      3: {
+        if (!isEmpty(value.fields[0])) {
+          if (head(value.fields[0]).tag === /* Value */
+          1) {
+            if (isEmpty(tail(value.fields[0]))) {
+              matchResult = 0;
+              v = head(value.fields[0]).fields[0];
+            } else {
+              matchResult = 1;
+              o = value.fields[0];
+            }
+          } else {
+            matchResult = 1;
+            o = value.fields[0];
+          }
+        } else {
+          matchResult = 1;
+          o = value.fields[0];
+        }
+        break;
+      }
+      default:
+        matchResult = 2;
+    }
+    switch (matchResult) {
+      case 0:
+        return v.Value;
+      case 1:
+        return void 0;
+      default:
+        throw new Error("Unexpected YAMLElement");
+    }
+  });
+  if (cwlType == null) {
+    return [(objectArg_1 = get$.Required, objectArg_1.Field("type", Decode_cwlArrayTypeDecoder)), false];
+  } else {
+    return Decode_cwlTypeStringMatcher(value(cwlType), get$);
+  }
+}, value_1);
+const Decode_outputArrayDecoder = (value_1) => object((get$) => {
+  const dict = get$.Overflow.FieldList(empty());
+  const collection = toArray(delay(() => collect((key) => {
+    let v;
+    const value = getItemFromDict(dict, key);
+    const outputBinding = Decode_outputBindingDecoder(value);
+    const outputSource = Decode_outputSourceDecoder(value);
+    const output = new CWLOutput(key, value.tag === /* Object */
+    3 ? !isEmpty(value.fields[0]) ? head(value.fields[0]).tag === /* Value */
+    1 ? isEmpty(tail(value.fields[0])) ? (v = head(value.fields[0]).fields[0], Decode_cwlTypeStringMatcher(v.Value, get$)[0]) : Decode_cwlTypeDecoder(value)[0] : Decode_cwlTypeDecoder(value)[0] : Decode_cwlTypeDecoder(value)[0] : Decode_cwlTypeDecoder(value)[0]);
+    return append(outputBinding != null ? (setOptionalProperty("outputBinding", outputBinding, output), empty$1()) : empty$1(), delay(() => append(outputSource != null ? (setOptionalProperty("outputSource", outputSource, output), empty$1()) : empty$1(), delay(() => singleton(output)))));
+  }, dict.keys())));
+  return Array.from(collection);
+}, value_1);
+const Decode_outputsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Required;
+  return objectArg.Field("outputs", Decode_outputArrayDecoder);
+}, value);
+function Decode_dockerRequirementDecoder(get$) {
+  let objectArg, objectArg_1, objectArg_2;
+  return new DockerRequirement((objectArg = get$.Optional, objectArg.Field("dockerPull", string)), (objectArg_1 = get$.Optional, objectArg_1.Field("dockerFile", (value_1) => map$1((x) => x, string, value_1))), (objectArg_2 = get$.Optional, objectArg_2.Field("dockerImageId", string)));
+}
+function Decode_envVarRequirementDecoder(get$) {
+  const objectArg = get$.Required;
+  return objectArg.Field("envDef", (value_3) => resizearray((value_2) => object((get2) => {
+    let objectArg_1, objectArg_2;
+    return new EnvironmentDef((objectArg_1 = get2.Required, objectArg_1.Field("envName", string)), (objectArg_2 = get2.Required, objectArg_2.Field("envValue", string)));
+  }, value_2), value_3));
+}
+function Decode_softwareRequirementDecoder(get$) {
+  const objectArg = get$.Required;
+  return objectArg.Field("packages", (value_6) => resizearray((value_5) => object((get2) => {
+    let objectArg_1, objectArg_2, objectArg_3;
+    return new SoftwarePackage((objectArg_1 = get2.Required, objectArg_1.Field("package", string)), (objectArg_2 = get2.Optional, objectArg_2.Field("version", (value_1) => resizearray(string, value_1))), (objectArg_3 = get2.Optional, objectArg_3.Field("specs", (value_3) => resizearray(string, value_3))));
+  }, value_5), value_6));
+}
+function Decode_initialWorkDirRequirementDecoder(get$) {
+  const objectArg = get$.Required;
+  return objectArg.Field("listing", (value) => resizearray(Decode_direntDecoder, value));
+}
+function Decode_resourceRequirementDecoder(get$) {
+  let objectArg, objectArg_1, objectArg_2, objectArg_3, objectArg_4, objectArg_5, objectArg_6, objectArg_7;
+  return ResourceRequirementInstance_$ctor_D76FC00(some((objectArg = get$.Optional, objectArg.Field("coresMin", (x) => x))), some((objectArg_1 = get$.Optional, objectArg_1.Field("coresMax", (x_1) => x_1))), some((objectArg_2 = get$.Optional, objectArg_2.Field("ramMin", (x_2) => x_2))), some((objectArg_3 = get$.Optional, objectArg_3.Field("ramMax", (x_3) => x_3))), some((objectArg_4 = get$.Optional, objectArg_4.Field("tmpdirMin", (x_4) => x_4))), some((objectArg_5 = get$.Optional, objectArg_5.Field("tmpdirMax", (x_5) => x_5))), some((objectArg_6 = get$.Optional, objectArg_6.Field("outdirMin", (x_6) => x_6))), some((objectArg_7 = get$.Optional, objectArg_7.Field("outdirMax", (x_7) => x_7))));
+}
+function Decode_schemaDefRequirementDecoder(get$) {
+  let objectArg;
+  return ResizeArray_map((m) => SchemaDefRequirementType_$ctor_541DA560(item(0, FSharpMap__get_Keys(m)), item(0, FSharpMap__get_Values(m))), (objectArg = get$.Required, objectArg.Field("types", (value_2) => resizearray((value) => map$1((x) => x, string, value), value_2))));
+}
+function Decode_toolTimeLimitRequirementDecoder(get$) {
+  const objectArg = get$.Required;
+  return objectArg.Field("timelimit", float);
+}
+const Decode_requirementArrayDecoder = (value_2) => resizearray((value_1) => object((get$) => {
+  let cls;
+  const objectArg = get$.Required;
+  cls = objectArg.Field("class", string);
+  switch (cls) {
+    case "InlineJavascriptRequirement":
+      return Requirement_InlineJavascriptRequirement();
+    case "SchemaDefRequirement":
+      return Requirement_SchemaDefRequirement(Decode_schemaDefRequirementDecoder(get$));
+    case "DockerRequirement":
+      return Requirement_DockerRequirement(Decode_dockerRequirementDecoder(get$));
+    case "SoftwareRequirement":
+      return Requirement_SoftwareRequirement(Decode_softwareRequirementDecoder(get$));
+    case "InitialWorkDirRequirement":
+      return Requirement_InitialWorkDirRequirement(Decode_initialWorkDirRequirementDecoder(get$));
+    case "EnvVarRequirement":
+      return Requirement_EnvVarRequirement(Decode_envVarRequirementDecoder(get$));
+    case "ShellCommandRequirement":
+      return Requirement_ShellCommandRequirement();
+    case "ResourceRequirement":
+      return Requirement_ResourceRequirement(Decode_resourceRequirementDecoder(get$));
+    case "WorkReuse":
+      return Requirement_WorkReuseRequirement();
+    case "NetworkAccess":
+      return Requirement_NetworkAccessRequirement();
+    case "InplaceUpdateRequirement":
+      return Requirement_InplaceUpdateRequirement();
+    case "ToolTimeLimit":
+      return Requirement_ToolTimeLimitRequirement(Decode_toolTimeLimitRequirementDecoder(get$));
+    case "SubworkflowFeatureRequirement":
+      return Requirement_SubworkflowFeatureRequirement();
+    case "ScatterFeatureRequirement":
+      return Requirement_ScatterFeatureRequirement();
+    case "MultipleInputFeatureRequirement":
+      return Requirement_MultipleInputFeatureRequirement();
+    case "StepInputExpressionRequirement":
+      return Requirement_StepInputExpressionRequirement();
+    default:
+      throw new Error("Invalid requirement");
+  }
+}, value_1), value_2);
+const Decode_requirementsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("requirements", Decode_requirementArrayDecoder);
+}, value);
+const Decode_hintsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("hints", Decode_requirementArrayDecoder);
+}, value);
+const Decode_inputBindingDecoder = (value_5) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("inputBinding", (value_4) => object((get$0027) => {
+    let objectArg_1, objectArg_2, objectArg_3, objectArg_4;
+    return new InputBinding((objectArg_1 = get$0027.Optional, objectArg_1.Field("prefix", string)), (objectArg_2 = get$0027.Optional, objectArg_2.Field("position", int)), (objectArg_3 = get$0027.Optional, objectArg_3.Field("itemSeparator", string)), (objectArg_4 = get$0027.Optional, objectArg_4.Field("separate", bool)));
+  }, value_4));
+}, value_5);
+const Decode_inputArrayDecoder = (value_1) => object((get$) => {
+  const dict = get$.Overflow.FieldList(empty());
+  const collection = toArray(delay(() => collect((key) => {
+    let v;
+    const value = getItemFromDict(dict, key);
+    const inputBinding = Decode_inputBindingDecoder(value);
+    const patternInput = value.tag === /* Object */
+    3 ? !isEmpty(value.fields[0]) ? head(value.fields[0]).tag === /* Value */
+    1 ? isEmpty(tail(value.fields[0])) ? (v = head(value.fields[0]).fields[0], Decode_cwlTypeStringMatcher(v.Value, get$)) : Decode_cwlTypeDecoder(value) : Decode_cwlTypeDecoder(value) : Decode_cwlTypeDecoder(value) : Decode_cwlTypeDecoder(value);
+    const input = new CWLInput(key, patternInput[0]);
+    return append(inputBinding != null ? (setOptionalProperty("inputBinding", inputBinding, input), empty$1()) : empty$1(), delay(() => append(patternInput[1] ? (setOptionalProperty("optional", true, input), empty$1()) : empty$1(), delay(() => singleton(input)))));
+  }, dict.keys())));
+  return Array.from(collection);
+}, value_1);
+const Decode_inputsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("inputs", Decode_inputArrayDecoder);
+}, value);
+const Decode_baseCommandDecoder = (value_2) => object((get$) => {
+  const objectArg = get$.Optional;
+  return objectArg.Field("baseCommand", (value) => resizearray(string, value));
+}, value_2);
+const Decode_versionDecoder = (value_1) => object((get$) => {
+  const objectArg = get$.Required;
+  return objectArg.Field("cwlVersion", string);
+}, value_1);
+const Decode_classDecoder = (value_1) => object((get$) => {
+  const objectArg = get$.Required;
+  return objectArg.Field("class", string);
+}, value_1);
+function Decode_stringOptionFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    const objectArg = get$.Optional;
+    return objectArg.Field(field, string);
+  }, value_1);
+}
+function Decode_stringFieldDecoder(field) {
+  return (value_1) => object((get$) => {
+    const objectArg = get$.Required;
+    return objectArg.Field(field, string);
+  }, value_1);
+}
+const Decode_inputStepDecoder = (value_1) => object((get$) => {
+  const dict = get$.Overflow.FieldList(empty());
+  const collection = toArray(delay(() => collect((key) => {
+    let s1, v, s2;
+    const value$1 = getItemFromDict(dict, key);
+    return singleton(new StepInput(key, (s1 = value$1.tag === /* Object */
+    3 ? !isEmpty(value$1.fields[0]) ? head(value$1.fields[0]).tag === /* Value */
+    1 ? isEmpty(tail(value$1.fields[0])) ? (v = head(value$1.fields[0]).fields[0], v.Value) : void 0 : void 0 : void 0 : void 0, s2 = Decode_stringOptionFieldDecoder("source")(value$1), s1 != null ? value(s1) : s2 != null ? value(s2) : void 0), Decode_stringOptionFieldDecoder("default")(value$1), Decode_stringOptionFieldDecoder("valueFrom")(value$1)));
+  }, dict.keys())));
+  return Array.from(collection);
+}, value_1);
+const Decode_outputStepsDecoder = (value_2) => object((get$) => {
+  const objectArg = get$.Required;
+  return objectArg.Field("out", (value) => resizearray(string, value));
+}, value_2);
+const Decode_stepArrayDecoder = (value_1) => object((get$) => {
+  const dict = get$.Overflow.FieldList(empty());
+  const collection = toArray(delay(() => collect((key) => {
+    const value = getItemFromDict(dict, key);
+    const run = Decode_stringFieldDecoder("run")(value);
+    const inputs = object((get$_1) => {
+      const objectArg = get$_1.Required;
+      return objectArg.Field("in", Decode_inputStepDecoder);
+    }, value);
+    const outputs = new StepOutput(Decode_outputStepsDecoder(value));
+    const requirements = Decode_requirementsDecoder(value);
+    const hints = Decode_hintsDecoder(value);
+    const wfStep = new WorkflowStep(key, inputs, outputs, run);
+    return append(requirements != null ? (wfStep.Requirements = requirements, empty$1()) : empty$1(), delay(() => append(hints != null ? (wfStep.Hints = hints, empty$1()) : empty$1(), delay(() => singleton(wfStep)))));
+  }, dict.keys())));
+  return Array.from(collection);
+}, value_1);
+const Decode_stepsDecoder = (value) => object((get$) => {
+  const objectArg = get$.Required;
+  return objectArg.Field("steps", Decode_stepArrayDecoder);
+}, value);
+function Decode_commandLineToolDecoder(yamlCWL) {
+  const cwlVersion = Decode_versionDecoder(yamlCWL);
+  const outputs = Decode_outputsDecoder(yamlCWL);
+  const inputs = Decode_inputsDecoder(yamlCWL);
+  const requirements = Decode_requirementsDecoder(yamlCWL);
+  const hints = Decode_hintsDecoder(yamlCWL);
+  const baseCommand = Decode_baseCommandDecoder(yamlCWL);
+  const description = new CWLToolDescription(outputs, cwlVersion);
+  let metadata;
+  const md = new DynamicObj();
+  object((get$) => Decode_overflowDecoder(md, get$.Overflow.FieldList(ofArray(["inputs", "outputs", "class", "id", "label", "doc", "requirements", "hints", "cwlVersion", "baseCommand", "arguments", "stdin", "stderr", "stdout", "successCodes", "temporaryFailCodes", "permanentFailCodes"]))), yamlCWL);
+  metadata = md;
+  object((get$_1) => Decode_overflowDecoder(description, get$_1.MultipleOptional.FieldList(ofArray(["id", "label", "doc", "arguments", "stdin", "stderr", "stdout", "successCodes", "temporaryFailCodes", "permanentFailCodes"]))), yamlCWL);
+  if (inputs != null) {
+    description.Inputs = inputs;
+  }
+  if (requirements != null) {
+    description.Requirements = requirements;
+  }
+  if (hints != null) {
+    description.Hints = hints;
+  }
+  if (baseCommand != null) {
+    description.BaseCommand = baseCommand;
+  }
+  if (length(metadata.GetProperties(false)) > 0) {
+    description.Metadata = metadata;
+  }
+  return description;
+}
+function Decode_decodeCommandLineTool(cwl) {
+  return Decode_commandLineToolDecoder(read(cwl));
+}
+function Decode_workflowDecoder(yamlCWL) {
+  const cwlVersion = Decode_versionDecoder(yamlCWL);
+  const outputs = Decode_outputsDecoder(yamlCWL);
+  let inputs;
+  const matchValue = Decode_inputsDecoder(yamlCWL);
+  if (matchValue == null) {
+    throw new Error("Inputs are required for a workflow");
+  } else {
+    inputs = value(matchValue);
+  }
+  const requirements = Decode_requirementsDecoder(yamlCWL);
+  const hints = Decode_hintsDecoder(yamlCWL);
+  const description = new CWLWorkflowDescription(Decode_stepsDecoder(yamlCWL), inputs, outputs, cwlVersion);
+  let metadata;
+  const md = new DynamicObj();
+  object((get$) => Decode_overflowDecoder(md, get$.Overflow.FieldList(ofArray(["inputs", "outputs", "class", "steps", "id", "label", "doc", "requirements", "hints", "cwlVersion"]))), yamlCWL);
+  metadata = md;
+  object((get$_1) => Decode_overflowDecoder(description, get$_1.MultipleOptional.FieldList(ofArray(["id", "label", "doc"]))), yamlCWL);
+  if (requirements != null) {
+    description.Requirements = requirements;
+  }
+  if (hints != null) {
+    description.Hints = hints;
+  }
+  if (length(metadata.GetProperties(false)) > 0) {
+    description.Metadata = metadata;
+  }
+  return description;
+}
+function Decode_decodeWorkflow(cwl) {
+  return Decode_workflowDecoder(read(cwl));
+}
+function Decode_decodeCWLProcessingUnit(cwl) {
+  const yamlCWL = read(cwl);
+  const cls = Decode_classDecoder(yamlCWL);
+  switch (cls) {
+    case "CommandLineTool":
+      return CWLProcessingUnit_CommandLineTool(Decode_commandLineToolDecoder(yamlCWL));
+    case "Workflow":
+      return CWLProcessingUnit_Workflow(Decode_workflowDecoder(yamlCWL));
+    default:
+      return toFail(printf("Invalid CWL class: %s"))(cls);
+  }
+}
+function DecodeParameters_cwlParameterReferenceDecoder(get$, key, yEle) {
+  let matchResult, v, v1, v2, s;
+  if (yEle.tag === /* Object */
+  3) {
+    if (!isEmpty(yEle.fields[0])) {
+      switch (head(yEle.fields[0]).tag) {
+        case /* Value */
+        1: {
+          if (isEmpty(tail(yEle.fields[0]))) {
+            matchResult = 0;
+            v = head(yEle.fields[0]).fields[0];
+          } else {
+            matchResult = 3;
+          }
+          break;
+        }
+        case /* Mapping */
+        0: {
+          if (head(yEle.fields[0]).fields[1].tag === /* Object */
+          3) {
+            if (!isEmpty(head(yEle.fields[0]).fields[1].fields[0])) {
+              if (head(head(yEle.fields[0]).fields[1].fields[0]).tag === /* Value */
+              1) {
+                if (isEmpty(tail(head(yEle.fields[0]).fields[1].fields[0]))) {
+                  if (!isEmpty(tail(yEle.fields[0]))) {
+                    if (head(tail(yEle.fields[0])).tag === /* Mapping */
+                    0) {
+                      if (head(tail(yEle.fields[0])).fields[1].tag === /* Object */
+                      3) {
+                        if (!isEmpty(head(tail(yEle.fields[0])).fields[1].fields[0])) {
+                          if (head(head(tail(yEle.fields[0])).fields[1].fields[0]).tag === /* Value */
+                          1) {
+                            if (isEmpty(tail(head(tail(yEle.fields[0])).fields[1].fields[0]))) {
+                              if (isEmpty(tail(tail(yEle.fields[0])))) {
+                                matchResult = 1;
+                                v1 = head(head(yEle.fields[0]).fields[1].fields[0]).fields[0];
+                                v2 = head(head(tail(yEle.fields[0])).fields[1].fields[0]).fields[0];
+                              } else {
+                                matchResult = 3;
+                              }
+                            } else {
+                              matchResult = 3;
+                            }
+                          } else {
+                            matchResult = 3;
+                          }
+                        } else {
+                          matchResult = 3;
+                        }
+                      } else {
+                        matchResult = 3;
+                      }
+                    } else {
+                      matchResult = 3;
+                    }
+                  } else {
+                    matchResult = 3;
+                  }
+                } else {
+                  matchResult = 3;
+                }
+              } else {
+                matchResult = 3;
+              }
+            } else {
+              matchResult = 3;
+            }
+          } else {
+            matchResult = 3;
+          }
+          break;
+        }
+        case /* Sequence */
+        2: {
+          if (isEmpty(tail(yEle.fields[0]))) {
+            matchResult = 2;
+            s = head(yEle.fields[0]).fields[0];
+          } else {
+            matchResult = 3;
+          }
+          break;
+        }
+        default:
+          matchResult = 3;
+      }
+    } else {
+      matchResult = 3;
+    }
+  } else {
+    matchResult = 3;
+  }
+  switch (matchResult) {
+    case 0:
+      return new CWLParameterReference(key, [v.Value]);
+    case 1:
+      return new CWLParameterReference(key, [v2.Value], Decode_cwlTypeStringMatcher(v1.Value, get$)[0]);
+    case 2:
+      return new CWLParameterReference(key, resizearray(string, YAMLElement_Sequence(s)));
+    default:
+      throw new Error(`${yEle}`);
+  }
+}
+const DecodeParameters_cwlparameterReferenceArrayDecoder = (value) => object((get$) => {
+  const dict = get$.Overflow.FieldList(empty());
+  const collection = toArray(delay(() => map$2((ele) => DecodeParameters_cwlParameterReferenceDecoder(get$, ele[0], ele[1]), dict)));
+  return Array.from(collection);
+}, value);
+function DecodeParameters_decodeYAMLParameterFile(yaml) {
+  return DecodeParameters_cwlparameterReferenceArrayDecoder(read(yaml));
+}
+
+export { DecodeParameters_cwlParameterReferenceDecoder, DecodeParameters_cwlparameterReferenceArrayDecoder, DecodeParameters_decodeYAMLParameterFile, Decode_baseCommandDecoder, Decode_classDecoder, Decode_commandLineToolDecoder, Decode_cwlArrayTypeDecoder, Decode_cwlTypeDecoder, Decode_cwlTypeStringMatcher, Decode_decodeCWLProcessingUnit, Decode_decodeCommandLineTool, Decode_decodeStringOrExpression, Decode_decodeWorkflow, Decode_direntDecoder, Decode_dockerRequirementDecoder, Decode_envVarRequirementDecoder, Decode_hintsDecoder, Decode_initialWorkDirRequirementDecoder, Decode_inputArrayDecoder, Decode_inputBindingDecoder, Decode_inputStepDecoder, Decode_inputsDecoder, Decode_outputArrayDecoder, Decode_outputBindingDecoder, Decode_outputBindingGlobDecoder, Decode_outputSourceDecoder, Decode_outputStepsDecoder, Decode_outputsDecoder, Decode_overflowDecoder, Decode_requirementArrayDecoder, Decode_requirementsDecoder, Decode_resourceRequirementDecoder, Decode_schemaDefRequirementDecoder, Decode_softwareRequirementDecoder, Decode_stepArrayDecoder, Decode_stepsDecoder, Decode_stringFieldDecoder, Decode_stringOptionFieldDecoder, Decode_toolTimeLimitRequirementDecoder, Decode_versionDecoder, Decode_workflowDecoder, ResizeArray_map };

package/dist/ts/ts/CWL/Encode.d.ts

@@ -0,0 +1,28 @@
+import { YAMLElement_$union } from '../fable_modules/YAMLicious.0.0.3/YAMLiciousTypes.fs.js';
+import { FSharpList } from '@fable-org/fable-library-js/List.js';
+import { SchemaDefRequirementType, CWLType_$union } from './CWLTypes.js';
+import { CWLOutput, OutputBinding } from './Outputs.js';
+import { CWLInput, InputBinding } from './Inputs.js';
+import { Requirement_$union } from './Requirements.js';
+import { WorkflowStep, StepOutput, StepInput } from './WorkflowSteps.js';
+import { CWLToolDescription } from './ToolDescription.js';
+import { CWLWorkflowDescription } from './WorkflowDescription.js';
+import { CWLProcessingUnit_$union } from './CWLProcessingUnit.js';
+export declare function yBool(b: boolean): YAMLElement_$union;
+export declare function yMap(pairs: FSharpList<[string, YAMLElement_$union]>): YAMLElement_$union;
+export declare function encodeCWLType(t: CWLType_$union): YAMLElement_$union;
+export declare function encodeOutputBinding(ob: OutputBinding): YAMLElement_$union;
+export declare function encodeCWLOutput(o: CWLOutput): [string, YAMLElement_$union];
+export declare function encodeInputBinding(ib: InputBinding): YAMLElement_$union;
+export declare function encodeCWLInput(i: CWLInput): [string, YAMLElement_$union];
+export declare function encodeSchemaDefRequirementType(s: SchemaDefRequirementType): YAMLElement_$union;
+export declare function encodeRequirement(r: Requirement_$union): YAMLElement_$union;
+export declare function encodeStepInput(si: StepInput): [string, YAMLElement_$union];
+export declare function encodeStepInputs(inputs: StepInput[]): YAMLElement_$union;
+export declare function encodeStepOutput(so: StepOutput): YAMLElement_$union;
+export declare function encodeWorkflowStep(ws: WorkflowStep): [string, YAMLElement_$union];
+export declare function writeYaml(element: YAMLElement_$union): string;
+export declare function encodeToolDescription(td: CWLToolDescription): string;
+export declare function encodeWorkflowDescription(wd: CWLWorkflowDescription): string;
+export declare function encodeProcessingUnit(pu: CWLProcessingUnit_$union): string;
+//# sourceMappingURL=Encode.d.ts.map