@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/esm/ts/Core/Process/ProcessInput.js

@@ -0,0 +1,283 @@
+import { Union, toString } from "@fable-org/fable-library-js/Types.js";
+import { Source_create_Z5CA08497, Source_getUnits_53E41069, Source_setCharacteristicValues, Source_get_empty, Source_$reflection } from "./Source.js";
+import { printf, toText } from "@fable-org/fable-library-js/String.js";
+import { Material_create_Z66909A6D, Material_getUnits_ZBCDEB61, Material_setCharacteristicValues, Material_$reflection } from "./Material.js";
+import { Data_$reflection, Data } from "../Data.js";
+import { Sample_create_62424AD2, Sample_getUnits_53716792, Sample_setCharacteristicValues, Sample_$reflection } from "./Sample.js";
+import { union_type } from "@fable-org/fable-library-js/Reflection.js";
+import { unwrap, map, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { empty, choose } from "@fable-org/fable-library-js/List.js";
+import { DataFile_DerivedDataFile, DataFile_RawDataFile, DataFile_ImageFile } from "../DataFile.js";
+export function ProcessInput_Source(Item) {
+    return new ProcessInput(0, [Item]);
+}
+export function ProcessInput_Sample(Item) {
+    return new ProcessInput(1, [Item]);
+}
+export function ProcessInput_Data(Item) {
+    return new ProcessInput(2, [Item]);
+}
+export function ProcessInput_Material(Item) {
+    return new ProcessInput(3, [Item]);
+}
+export class ProcessInput extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Source", "Sample", "Data", "Material"];
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* Source */ 0: {
+                const s_1 = this$.fields[0];
+                const arg_1 = s_1.PrintCompact();
+                return toText(printf("Source {%s}"))(arg_1);
+            }
+            case /* Material */ 3: {
+                const m = this$.fields[0];
+                const arg_2 = m.PrintCompact();
+                return toText(printf("Material {%s}"))(arg_2);
+            }
+            case /* Data */ 2: {
+                const d = this$.fields[0];
+                const arg_3 = d.PrintCompact();
+                return toText(printf("Data {%s}"))(arg_3);
+            }
+            default: {
+                const s = this$.fields[0];
+                const arg = s.PrintCompact();
+                return toText(printf("Sample {%s}"))(arg);
+            }
+        }
+    }
+}
+export function ProcessInput_$reflection() {
+    return union_type("ARCtrl.Process.ProcessInput", [], ProcessInput, () => [[["Item", Source_$reflection()]], [["Item", Sample_$reflection()]], [["Item", Data_$reflection()]], [["Item", Material_$reflection()]]]);
+}
+export function ProcessInput__get_TryName(this$) {
+    switch (this$.tag) {
+        case /* Source */ 0:
+            return this$.fields[0].Name;
+        case /* Material */ 3:
+            return this$.fields[0].Name;
+        case /* Data */ 2: {
+            const d = this$.fields[0];
+            return d.Name;
+        }
+        default:
+            return this$.fields[0].Name;
+    }
+}
+export function ProcessInput__get_Name(this$) {
+    return defaultArg(ProcessInput__get_TryName(this$), "");
+}
+export function ProcessInput_get_Default() {
+    return ProcessInput_Source(Source_get_empty());
+}
+/**
+ * Returns name of processInput
+ */
+export function ProcessInput_tryGetName_5B3D5BA9(pi) {
+    return ProcessInput__get_TryName(pi);
+}
+/**
+ * Returns name of processInput
+ */
+export function ProcessInput_getName_5B3D5BA9(pi) {
+    return ProcessInput__get_Name(pi);
+}
+/**
+ * Returns true, if given name equals name of processInput
+ */
+export function ProcessInput_nameEquals(name, pi) {
+    return ProcessInput__get_Name(pi) === name;
+}
+/**
+ * Returns true, if Process Input is Sample
+ */
+export function ProcessInput_isSample_5B3D5BA9(pi) {
+    if (pi.tag === /* Sample */ 1) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Returns true, if Process Input is Source
+ */
+export function ProcessInput_isSource_5B3D5BA9(pi) {
+    if (pi.tag === /* Source */ 0) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Returns true, if Process Input is Data
+ */
+export function ProcessInput_isData_5B3D5BA9(pi) {
+    if (pi.tag === /* Data */ 2) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Returns true, if Process Input is Material
+ */
+export function ProcessInput_isMaterial_5B3D5BA9(pi) {
+    if (pi.tag === /* Material */ 3) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Returns true, if Process Input is Source
+ */
+export function ProcessInput__isSource(this$) {
+    return ProcessInput_isSource_5B3D5BA9(this$);
+}
+/**
+ * Returns true, if Process Input is Sample
+ */
+export function ProcessInput__isSample(this$) {
+    return ProcessInput_isSample_5B3D5BA9(this$);
+}
+/**
+ * Returns true, if Process Input is Data
+ */
+export function ProcessInput__isData(this$) {
+    return ProcessInput_isData_5B3D5BA9(this$);
+}
+/**
+ * Returns true, if Process Input is Material
+ */
+export function ProcessInput__isMaterial(this$) {
+    return ProcessInput_isMaterial_5B3D5BA9(this$);
+}
+/**
+ * If given process input is a sample, returns it, else returns None
+ */
+export function ProcessInput_trySample_5B3D5BA9(pi) {
+    if (pi.tag === /* Sample */ 1) {
+        return pi.fields[0];
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If given process input is a source, returns it, else returns None
+ */
+export function ProcessInput_trySource_5B3D5BA9(pi) {
+    if (pi.tag === /* Source */ 0) {
+        return pi.fields[0];
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If given process input is a data, returns it, else returns None
+ */
+export function ProcessInput_tryData_5B3D5BA9(pi) {
+    if (pi.tag === /* Data */ 2) {
+        return pi.fields[0];
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If given process input is a material, returns it, else returns None
+ */
+export function ProcessInput_tryMaterial_5B3D5BA9(pi) {
+    if (pi.tag === /* Material */ 3) {
+        return pi.fields[0];
+    }
+    else {
+        return undefined;
+    }
+}
+export function ProcessInput_setCharacteristicValues(characteristics, pi) {
+    switch (pi.tag) {
+        case /* Source */ 0:
+            return ProcessInput_Source(Source_setCharacteristicValues(characteristics, pi.fields[0]));
+        case /* Material */ 3:
+            return ProcessInput_Material(Material_setCharacteristicValues(characteristics, pi.fields[0]));
+        case /* Data */ 2:
+            return pi;
+        default:
+            return ProcessInput_Sample(Sample_setCharacteristicValues(characteristics, pi.fields[0]));
+    }
+}
+/**
+ * If given process input contains characteristics, returns them
+ */
+export function ProcessInput_tryGetCharacteristicValues_5B3D5BA9(pi) {
+    switch (pi.tag) {
+        case /* Source */ 0:
+            return pi.fields[0].Characteristics;
+        case /* Material */ 3:
+            return pi.fields[0].Characteristics;
+        case /* Data */ 2:
+            return undefined;
+        default:
+            return pi.fields[0].Characteristics;
+    }
+}
+/**
+ * If given process input contains characteristics, returns them
+ */
+export function ProcessInput_tryGetCharacteristics_5B3D5BA9(pi) {
+    return map((list) => choose((c) => c.Category, list), ProcessInput_tryGetCharacteristicValues_5B3D5BA9(pi));
+}
+export function ProcessInput_getCharacteristicValues_5B3D5BA9(pi) {
+    return defaultArg(ProcessInput_tryGetCharacteristicValues_5B3D5BA9(pi), empty());
+}
+/**
+ * If given process output contains units, returns them
+ */
+export function ProcessInput_getUnits_5B3D5BA9(pi) {
+    switch (pi.tag) {
+        case /* Sample */ 1:
+            return Sample_getUnits_53716792(pi.fields[0]);
+        case /* Material */ 3:
+            return Material_getUnits_ZBCDEB61(pi.fields[0]);
+        case /* Data */ 2:
+            return empty();
+        default:
+            return Source_getUnits_53E41069(pi.fields[0]);
+    }
+}
+export function ProcessInput_createSource_Z5E00540E(name, characteristics) {
+    return ProcessInput_Source(Source_create_Z5CA08497(undefined, name, unwrap(characteristics)));
+}
+export function ProcessInput_createSample_Z598187B7(name, characteristics, factors, derivesFrom) {
+    return ProcessInput_Sample(Sample_create_62424AD2(undefined, name, unwrap(characteristics), unwrap(factors), unwrap(derivesFrom)));
+}
+export function ProcessInput_createMaterial_4452CB4C(name, characteristics, derivesFrom) {
+    return ProcessInput_Material(Material_create_Z66909A6D(undefined, name, undefined, unwrap(characteristics), unwrap(derivesFrom)));
+}
+export function ProcessInput_createImageFile_Z721C83C5(name) {
+    return ProcessInput_Data(Data.create(undefined, name, DataFile_ImageFile()));
+}
+export function ProcessInput_createRawData_Z721C83C5(name) {
+    return ProcessInput_Data(Data.create(undefined, name, DataFile_RawDataFile()));
+}
+export function ProcessInput_createDerivedData_Z721C83C5(name) {
+    return ProcessInput_Data(Data.create(undefined, name, DataFile_DerivedDataFile()));
+}

package/dist/ts/esm/ts/Core/Process/ProcessOutput.js

@@ -0,0 +1,248 @@
+import { Union, toString } from "@fable-org/fable-library-js/Types.js";
+import { Material_create_Z66909A6D, Material_getUnits_ZBCDEB61, Material_$reflection } from "./Material.js";
+import { printf, toText } from "@fable-org/fable-library-js/String.js";
+import { Data_$reflection, Data } from "../Data.js";
+import { Sample_create_62424AD2, Sample_getUnits_53716792, Sample_setFactorValues, Sample_get_empty, Sample_$reflection } from "./Sample.js";
+import { union_type } from "@fable-org/fable-library-js/Reflection.js";
+import { unwrap, map, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { empty, choose } from "@fable-org/fable-library-js/List.js";
+import { DataFile_DerivedDataFile, DataFile_RawDataFile, DataFile_ImageFile } from "../DataFile.js";
+export function ProcessOutput_Sample(Item) {
+    return new ProcessOutput(0, [Item]);
+}
+export function ProcessOutput_Data(Item) {
+    return new ProcessOutput(1, [Item]);
+}
+export function ProcessOutput_Material(Item) {
+    return new ProcessOutput(2, [Item]);
+}
+export class ProcessOutput extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Sample", "Data", "Material"];
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        const this$ = this;
+        switch (this$.tag) {
+            case /* Material */ 2: {
+                const m = this$.fields[0];
+                const arg_1 = m.PrintCompact();
+                return toText(printf("Material {%s}"))(arg_1);
+            }
+            case /* Data */ 1: {
+                const d = this$.fields[0];
+                const arg_2 = d.PrintCompact();
+                return toText(printf("Data {%s}"))(arg_2);
+            }
+            default: {
+                const s = this$.fields[0];
+                const arg = s.PrintCompact();
+                return toText(printf("Sample {%s}"))(arg);
+            }
+        }
+    }
+}
+export function ProcessOutput_$reflection() {
+    return union_type("ARCtrl.Process.ProcessOutput", [], ProcessOutput, () => [[["Item", Sample_$reflection()]], [["Item", Data_$reflection()]], [["Item", Material_$reflection()]]]);
+}
+export function ProcessOutput__get_TryName(this$) {
+    switch (this$.tag) {
+        case /* Material */ 2:
+            return this$.fields[0].Name;
+        case /* Data */ 1: {
+            const d = this$.fields[0];
+            return d.Name;
+        }
+        default:
+            return this$.fields[0].Name;
+    }
+}
+export function ProcessOutput__get_Name(this$) {
+    return defaultArg(ProcessOutput__get_TryName(this$), "");
+}
+export function ProcessOutput_get_Default() {
+    return ProcessOutput_Sample(Sample_get_empty());
+}
+/**
+ * Returns name of processOutput
+ */
+export function ProcessOutput_tryGetName_Z42C11600(po) {
+    return ProcessOutput__get_TryName(po);
+}
+/**
+ * Returns name of processInput
+ */
+export function ProcessOutput_getName_Z42C11600(po) {
+    return ProcessOutput__get_Name(po);
+}
+/**
+ * Returns true, if given name equals name of processOutput
+ */
+export function ProcessOutput_nameEquals(name, po) {
+    return ProcessOutput__get_Name(po) === name;
+}
+/**
+ * Returns true, if Process Output is Sample
+ */
+export function ProcessOutput_isSample_Z42C11600(po) {
+    if (po.tag === /* Sample */ 0) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Returns true, if Process Output is Data
+ */
+export function ProcessOutput_isData_Z42C11600(po) {
+    if (po.tag === /* Data */ 1) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Returns true, if Process Output is Material
+ */
+export function ProcessOutput_isMaterial_Z42C11600(po) {
+    if (po.tag === /* Material */ 2) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Returns true, if Process Output is Sample
+ */
+export function ProcessOutput__isSample(this$) {
+    return ProcessOutput_isSample_Z42C11600(this$);
+}
+/**
+ * Returns true, if Process Output is Data
+ */
+export function ProcessOutput__isData(this$) {
+    return ProcessOutput_isData_Z42C11600(this$);
+}
+/**
+ * Returns true, if Process Output is Material
+ */
+export function ProcessOutput__isMaterial(this$) {
+    return ProcessOutput_isMaterial_Z42C11600(this$);
+}
+/**
+ * If given process output is a sample, returns it, else returns None
+ */
+export function ProcessOutput_trySample_Z42C11600(po) {
+    if (po.tag === /* Sample */ 0) {
+        return po.fields[0];
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If given process output is a data, returns it, else returns None
+ */
+export function ProcessOutput_tryData_Z42C11600(po) {
+    if (po.tag === /* Data */ 1) {
+        return po.fields[0];
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If given process output is a material, returns it, else returns None
+ */
+export function ProcessOutput_tryMaterial_Z42C11600(po) {
+    if (po.tag === /* Material */ 2) {
+        return po.fields[0];
+    }
+    else {
+        return undefined;
+    }
+}
+/**
+ * If given process output contains characteristics, returns them
+ */
+export function ProcessOutput_tryGetCharacteristicValues_Z42C11600(po) {
+    switch (po.tag) {
+        case /* Material */ 2:
+            return po.fields[0].Characteristics;
+        case /* Data */ 1:
+            return undefined;
+        default:
+            return po.fields[0].Characteristics;
+    }
+}
+/**
+ * If given process output contains characteristics, returns them
+ */
+export function ProcessOutput_tryGetCharacteristics_Z42C11600(po) {
+    return map((list) => choose((c) => c.Category, list), ProcessOutput_tryGetCharacteristicValues_Z42C11600(po));
+}
+/**
+ * If given process output contains factors, returns them
+ */
+export function ProcessOutput_tryGetFactorValues_Z42C11600(po) {
+    switch (po.tag) {
+        case /* Material */ 2:
+            return undefined;
+        case /* Data */ 1:
+            return undefined;
+        default:
+            return po.fields[0].FactorValues;
+    }
+}
+export function ProcessOutput_setFactorValues(values, po) {
+    switch (po.tag) {
+        case /* Material */ 2:
+            return po;
+        case /* Data */ 1:
+            return po;
+        default:
+            return ProcessOutput_Sample(Sample_setFactorValues(values, po.fields[0]));
+    }
+}
+export function ProcessOutput_getFactorValues_Z42C11600(po) {
+    return defaultArg(ProcessOutput_tryGetFactorValues_Z42C11600(po), empty());
+}
+/**
+ * If given process output contains units, returns them
+ */
+export function ProcessOutput_getUnits_Z42C11600(po) {
+    switch (po.tag) {
+        case /* Material */ 2:
+            return Material_getUnits_ZBCDEB61(po.fields[0]);
+        case /* Data */ 1:
+            return empty();
+        default:
+            return Sample_getUnits_53716792(po.fields[0]);
+    }
+}
+export function ProcessOutput_createSample_Z598187B7(name, characteristics, factors, derivesFrom) {
+    return ProcessOutput_Sample(Sample_create_62424AD2(undefined, name, unwrap(characteristics), unwrap(factors), unwrap(derivesFrom)));
+}
+export function ProcessOutput_createMaterial_4452CB4C(name, characteristics, derivesFrom) {
+    return ProcessOutput_Material(Material_create_Z66909A6D(undefined, name, undefined, unwrap(characteristics), unwrap(derivesFrom)));
+}
+export function ProcessOutput_createImageFile_Z721C83C5(name) {
+    return ProcessOutput_Data(Data.create(undefined, name, DataFile_ImageFile()));
+}
+export function ProcessOutput_createRawData_Z721C83C5(name) {
+    return ProcessOutput_Data(Data.create(undefined, name, DataFile_RawDataFile()));
+}
+export function ProcessOutput_createDerivedData_Z721C83C5(name) {
+    return ProcessOutput_Data(Data.create(undefined, name, DataFile_DerivedDataFile()));
+}

package/dist/ts/esm/ts/Core/Process/ProcessParameterValue.js

@@ -0,0 +1,136 @@
+import { value as value_3, bind, unwrap, map, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { ProtocolParameter_$reflection, ProtocolParameter } from "./ProtocolParameter.js";
+import { Value_$reflection } from "../Value.js";
+import { OntologyAnnotation_$reflection } from "../OntologyAnnotation.js";
+import { int32ToString } from "@fable-org/fable-library-js/Util.js";
+import { printf, toText } from "@fable-org/fable-library-js/String.js";
+import { Record, toString } from "@fable-org/fable-library-js/Types.js";
+import { record_type, option_type } from "@fable-org/fable-library-js/Reflection.js";
+export class ProcessParameterValue extends Record {
+    constructor(Category, Value, Unit) {
+        super();
+        this.Category = Category;
+        this.Value = Value;
+        this.Unit = Unit;
+    }
+    static make(category, value, unit) {
+        return new ProcessParameterValue(category, value, unit);
+    }
+    static create(Category, Value, Unit) {
+        return ProcessParameterValue.make(Category, Value, Unit);
+    }
+    static get empty() {
+        return ProcessParameterValue.create();
+    }
+    get NameText() {
+        const this$ = this;
+        return defaultArg(map((oa) => oa.NameText, this$.Category), "");
+    }
+    get TryNameText() {
+        const this$ = this;
+        return unwrap(bind((oa) => oa.TryNameText, this$.Category));
+    }
+    get ValueText() {
+        const this$ = this;
+        return defaultArg(map((oa) => {
+            switch (oa.tag) {
+                case /* Float */ 2: {
+                    const f = oa.fields[0];
+                    return f.toString();
+                }
+                case /* Int */ 1:
+                    return int32ToString(oa.fields[0]);
+                case /* Name */ 3:
+                    return oa.fields[0];
+                default: {
+                    const oa_1 = oa.fields[0];
+                    return oa_1.NameText;
+                }
+            }
+        }, this$.Value), "");
+    }
+    get ValueWithUnitText() {
+        const this$ = this;
+        const unit = map((oa) => oa.NameText, this$.Unit);
+        const v = this$.ValueText;
+        if (unit == null) {
+            return v;
+        }
+        else {
+            const u = value_3(unit);
+            return toText(printf("%s %s"))(v)(u);
+        }
+    }
+    MapCategory(f) {
+        const this$ = this;
+        return new ProcessParameterValue(map((p) => p.MapCategory(f), this$.Category), this$.Value, this$.Unit);
+    }
+    SetCategory(c) {
+        let matchValue, p;
+        const this$ = this;
+        return new ProcessParameterValue((matchValue = this$.Category, (matchValue == null) ? ProtocolParameter.create(undefined, c) : ((p = value_3(matchValue), p.SetCategory(c)))), this$.Value, this$.Unit);
+    }
+    static tryGetNameText(pv) {
+        return pv.TryNameText;
+    }
+    static getNameText(pv) {
+        return pv.NameText;
+    }
+    static nameEqualsString(name, pv) {
+        return pv.NameText === name;
+    }
+    static getCategory(pv) {
+        return pv.Category;
+    }
+    static createAsPV(alternateName, measurementMethod, description, category, value, unit) {
+        const category_1 = map((c) => ProtocolParameter.create(undefined, c), category);
+        return ProcessParameterValue.create(unwrap(category_1), unwrap(value), unwrap(unit));
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        let value_2, category_2, category_1, value_1;
+        const this$ = this;
+        const category = map((f) => f.NameText, this$.Category);
+        const unit = map((oa) => oa.NameText, this$.Unit);
+        const value = map((v) => {
+            const s = v.PrintCompact();
+            if (unit == null) {
+                return s;
+            }
+            else {
+                return (s + " ") + value_3(unit);
+            }
+        }, this$.Value);
+        return (category == null) ? ((value == null) ? "" : ((value_2 = value_3(value), value_2))) : ((value == null) ? ((category_2 = value_3(category), (category_2 + ":") + "No Value")) : ((category_1 = value_3(category), (value_1 = value_3(value), (category_1 + ":") + value_1))));
+    }
+    AlternateName() {
+        return undefined;
+    }
+    MeasurementMethod() {
+        return undefined;
+    }
+    Description() {
+        return undefined;
+    }
+    GetCategory() {
+        const this$ = this;
+        return bind((p) => p.ParameterName, this$.Category);
+    }
+    GetAdditionalType() {
+        return "ProcessParameterValue";
+    }
+    GetValue() {
+        const this$ = this;
+        return this$.Value;
+    }
+    GetUnit() {
+        const this$ = this;
+        return this$.Unit;
+    }
+}
+export function ProcessParameterValue_$reflection() {
+    return record_type("ARCtrl.Process.ProcessParameterValue", [], ProcessParameterValue, () => [["Category", option_type(ProtocolParameter_$reflection())], ["Value", option_type(Value_$reflection())], ["Unit", option_type(OntologyAnnotation_$reflection())]]);
+}