@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

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

@@ -0,0 +1,227 @@
+import { List_groupBy, List_distinct } from "@fable-org/fable-library-js/Seq2.js";
+import { singleton, zip, map, empty, collect, concat, filter, choose } from "@fable-org/fable-library-js/List.js";
+import { defaultArg, value as value_4, bind } from "@fable-org/fable-library-js/Option.js";
+import { Process_getMaterials_763471FF, Process_getSamples_763471FF, Process_getSources_763471FF, Process_getData_763471FF, Process_getUnits_763471FF, Process_getFactors_763471FF, Process_tryGetOutputsWithFactorBy, Process_tryGetOutputsWithCharacteristicBy, Process_tryGetInputsWithCharacteristicBy, Process_getCharacteristics_763471FF, Process_getParameters_763471FF, Process_tryGetOutputsWithParameterBy, Process_tryGetInputsWithParameterBy } from "./Process.js";
+import { arrayHash, equalArrays, comparePrimitives, safeHash, equals, stringHash } from "@fable-org/fable-library-js/Util.js";
+import { ProcessInput__get_Name, ProcessInput_getName_5B3D5BA9 } from "./ProcessInput.js";
+import { ProcessOutput__get_Name, ProcessOutput_getName_Z42C11600 } from "./ProcessOutput.js";
+import { FSharpSet__Contains, ofList } from "@fable-org/fable-library-js/Set.js";
+import { FSharpMap__TryFind, ofList as ofList_1 } from "@fable-org/fable-library-js/Map.js";
+/**
+ * Returns the names of the protocols the given processes impelement
+ */
+export function getProtocolNames(processSequence) {
+    return List_distinct(choose((p) => bind((protocol) => protocol.Name, p.ExecutesProtocol), processSequence), {
+        Equals: (x, y) => (x === y),
+        GetHashCode: stringHash,
+    });
+}
+/**
+ * Returns the protocols the given processes impelement
+ */
+export function getProtocols(processSequence) {
+    return List_distinct(choose((p) => p.ExecutesProtocol, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+/**
+ * Returns a list of the processes, containing only the ones executing a protocol for which the predicate returns true
+ */
+export function filterByProtocolBy(predicate, processSequence) {
+    return filter((p) => {
+        const matchValue = p.ExecutesProtocol;
+        let matchResult, protocol_1;
+        if (matchValue != null) {
+            if (predicate(value_4(matchValue))) {
+                matchResult = 0;
+                protocol_1 = value_4(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return true;
+            default:
+                return false;
+        }
+    }, processSequence);
+}
+/**
+ * Returns a list of the processes, containing only the ones executing a protocol with the given name
+ */
+export function filterByProtocolName(protocolName, processSequence) {
+    return filterByProtocolBy((p) => equals(p.Name, protocolName), processSequence);
+}
+/**
+ * If the processes contain a process implementing the given parameter, return the list of input files together with their according parameter values of this parameter
+ */
+export function getInputsWithParameterBy(predicate, processSequence) {
+    return concat(choose((p) => Process_tryGetInputsWithParameterBy(predicate, p), processSequence));
+}
+/**
+ * If the processes contain a process implementing the given parameter, return the list of output files together with their according parameter values of this parameter
+ */
+export function getOutputsWithParameterBy(predicate, processSequence) {
+    return concat(choose((p) => Process_tryGetOutputsWithParameterBy(predicate, p), processSequence));
+}
+/**
+ * Returns the parameters implemented by the processes contained in these processes
+ */
+export function getParameters(processSequence) {
+    return List_distinct(collect(Process_getParameters_763471FF, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+/**
+ * Returns the characteristics describing the inputs and outputs of the processssequence
+ */
+export function getCharacteristics(processSequence) {
+    return List_distinct(collect(Process_getCharacteristics_763471FF, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+/**
+ * If the processes contain a process implementing the given parameter, return the list of input files together with their according parameter values of this parameter
+ */
+export function getInputsWithCharacteristicBy(predicate, processSequence) {
+    return concat(choose((p) => Process_tryGetInputsWithCharacteristicBy(predicate, p), processSequence));
+}
+/**
+ * If the processes contain a process implementing the given parameter, return the list of output files together with their according parameter values of this parameter
+ */
+export function getOutputsWithCharacteristicBy(predicate, processSequence) {
+    return concat(choose((p) => Process_tryGetOutputsWithCharacteristicBy(predicate, p), processSequence));
+}
+/**
+ * If the processes contain a process implementing the given factor, return the list of output files together with their according factor values of this factor
+ */
+export function getOutputsWithFactorBy(predicate, processSequence) {
+    return concat(choose((p) => Process_tryGetOutputsWithFactorBy(predicate, p), processSequence));
+}
+/**
+ * Returns the factors implemented by the processes contained in these processes
+ */
+export function getFactors(processSequence) {
+    return List_distinct(collect(Process_getFactors_763471FF, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+/**
+ * Returns the initial inputs final outputs of the processSequence, to which no processPoints
+ */
+export function getRootInputs(processSequence) {
+    const inputs = collect((p) => defaultArg(p.Inputs, empty()), processSequence);
+    const outputs = ofList(collect((p_1) => map(ProcessOutput_getName_Z42C11600, defaultArg(p_1.Outputs, empty())), processSequence), {
+        Compare: comparePrimitives,
+    });
+    return filter((i) => !FSharpSet__Contains(outputs, ProcessInput_getName_5B3D5BA9(i)), inputs);
+}
+/**
+ * Returns the final outputs of the processSequence, which point to no further nodes
+ */
+export function getFinalOutputs(processSequence) {
+    const inputs = ofList(collect((p) => map(ProcessInput_getName_5B3D5BA9, defaultArg(p.Inputs, empty())), processSequence), {
+        Compare: comparePrimitives,
+    });
+    return filter((o) => !FSharpSet__Contains(inputs, ProcessOutput_getName_Z42C11600(o)), collect((p_1) => defaultArg(p_1.Outputs, empty()), processSequence));
+}
+/**
+ * Returns the initial inputs final outputs of the processSequence, to which no processPoints
+ */
+export function getRootInputOf(processSequence, sample) {
+    const mappings = ofList_1(map((tupledArg) => [tupledArg[0], map((tuple_1) => tuple_1[1], tupledArg[1])], List_groupBy((tuple) => tuple[0], collect((p) => List_distinct(zip(map(ProcessOutput__get_Name, value_4(p.Outputs)), map(ProcessInput__get_Name, value_4(p.Inputs))), {
+        Equals: equalArrays,
+        GetHashCode: arrayHash,
+    }), processSequence), {
+        Equals: (x_1, y_1) => (x_1 === y_1),
+        GetHashCode: stringHash,
+    })), {
+        Compare: comparePrimitives,
+    });
+    const loop = (lastState_mut, state_mut) => {
+        loop: while (true) {
+            const lastState = lastState_mut, state = state_mut;
+            if (equals(lastState, state)) {
+                return state;
+            }
+            else {
+                lastState_mut = state;
+                state_mut = collect((s) => defaultArg(FSharpMap__TryFind(mappings, s), singleton(s)), state);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(empty(), singleton(sample));
+}
+/**
+ * Returns the final outputs of the processSequence, which point to no further nodes
+ */
+export function getFinalOutputsOf(processSequence, sample) {
+    const mappings = ofList_1(map((tupledArg) => [tupledArg[0], map((tuple_1) => tuple_1[1], tupledArg[1])], List_groupBy((tuple) => tuple[0], collect((p) => List_distinct(zip(map(ProcessInput__get_Name, value_4(p.Inputs)), map(ProcessOutput__get_Name, value_4(p.Outputs))), {
+        Equals: equalArrays,
+        GetHashCode: arrayHash,
+    }), processSequence), {
+        Equals: (x_1, y_1) => (x_1 === y_1),
+        GetHashCode: stringHash,
+    })), {
+        Compare: comparePrimitives,
+    });
+    const loop = (lastState_mut, state_mut) => {
+        loop: while (true) {
+            const lastState = lastState_mut, state = state_mut;
+            if (equals(lastState, state)) {
+                return state;
+            }
+            else {
+                lastState_mut = state;
+                state_mut = collect((s) => defaultArg(FSharpMap__TryFind(mappings, s), singleton(s)), state);
+                continue loop;
+            }
+            break;
+        }
+    };
+    return loop(empty(), singleton(sample));
+}
+export function getUnits(processSequence) {
+    return List_distinct(collect(Process_getUnits_763471FF, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+/**
+ * Returns the data the given processes contain
+ */
+export function getData(processSequence) {
+    return List_distinct(collect(Process_getData_763471FF, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+export function getSources(processSequence) {
+    return List_distinct(collect(Process_getSources_763471FF, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+export function getSamples(processSequence) {
+    return List_distinct(collect(Process_getSamples_763471FF, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}
+export function getMaterials(processSequence) {
+    return List_distinct(collect(Process_getMaterials_763471FF, processSequence), {
+        Equals: equals,
+        GetHashCode: safeHash,
+    });
+}

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

@@ -0,0 +1,210 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { defaultArg, map } from "@fable-org/fable-library-js/Option.js";
+import { OntologyAnnotation_$reflection } from "../OntologyAnnotation.js";
+import { empty, filter, singleton, append, exists, tryFind } from "@fable-org/fable-library-js/List.js";
+import { ProtocolParameter_$reflection } from "./ProtocolParameter.js";
+import { Component_$reflection } from "./Component.js";
+import { Comment$_$reflection } from "../Comment.js";
+import { equals } from "@fable-org/fable-library-js/Util.js";
+import { record_type, list_type, option_type, string_type } from "@fable-org/fable-library-js/Reflection.js";
+export class Protocol extends Record {
+    constructor(ID, Name, ProtocolType, Description, Uri, Version, Parameters, Components, Comments) {
+        super();
+        this.ID = ID;
+        this.Name = Name;
+        this.ProtocolType = ProtocolType;
+        this.Description = Description;
+        this.Uri = Uri;
+        this.Version = Version;
+        this.Parameters = Parameters;
+        this.Components = Components;
+        this.Comments = Comments;
+    }
+}
+export function Protocol_$reflection() {
+    return record_type("ARCtrl.Process.Protocol", [], Protocol, () => [["ID", option_type(string_type)], ["Name", option_type(string_type)], ["ProtocolType", option_type(OntologyAnnotation_$reflection())], ["Description", option_type(string_type)], ["Uri", option_type(string_type)], ["Version", option_type(string_type)], ["Parameters", option_type(list_type(ProtocolParameter_$reflection()))], ["Components", option_type(list_type(Component_$reflection()))], ["Comments", option_type(list_type(Comment$_$reflection()))]]);
+}
+export function Protocol_make(id, name, protocolType, description, uri, version, parameters, components, comments) {
+    return new Protocol(id, name, protocolType, description, uri, version, parameters, components, comments);
+}
+export function Protocol_create_Z414665E7(Id, Name, ProtocolType, Description, Uri, Version, Parameters, Components, Comments) {
+    return Protocol_make(Id, Name, ProtocolType, Description, Uri, Version, Parameters, Components, Comments);
+}
+export function Protocol_get_empty() {
+    return Protocol_create_Z414665E7();
+}
+/**
+ * If a protocol with the given identfier exists in the list, returns it
+ */
+export function Protocol_tryGetByName(name, protocols) {
+    return tryFind((p) => equals(p.Name, name), protocols);
+}
+/**
+ * If a protocol with the given name exists in the list exists, returns true
+ */
+export function Protocol_existsByName(name, protocols) {
+    return exists((p) => equals(p.Name, name), protocols);
+}
+/**
+ * Adds the given protocol to the protocols
+ */
+export function Protocol_add(protocols, protocol) {
+    return append(protocols, singleton(protocol));
+}
+/**
+ * If a protocol with the given name exists in the list, removes it
+ */
+export function Protocol_removeByName(name, protocols) {
+    return filter((p) => !equals(p.Name, name), protocols);
+}
+/**
+ * Returns comments of a protocol
+ */
+export function Protocol_getComments_3BF20962(protocol) {
+    return protocol.Comments;
+}
+/**
+ * Applies function f on comments of a protocol
+ */
+export function Protocol_mapComments(f, protocol) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, map(f, protocol.Comments));
+}
+/**
+ * Replaces comments of a protocol by given comment list
+ */
+export function Protocol_setComments(protocol, comments) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, comments);
+}
+/**
+ * Returns protocol type of a protocol
+ */
+export function Protocol_getProtocolType_3BF20962(protocol) {
+    return protocol.ProtocolType;
+}
+/**
+ * Applies function f on protocol type of a protocol
+ */
+export function Protocol_mapProtocolType(f, protocol) {
+    return new Protocol(protocol.ID, protocol.Name, map(f, protocol.ProtocolType), protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Replaces protocol type of a protocol by given protocol type
+ */
+export function Protocol_setProtocolType(protocol, protocolType) {
+    return new Protocol(protocol.ID, protocol.Name, protocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Returns protocol version of a protocol
+ */
+export function Protocol_getVersion_3BF20962(protocol) {
+    return protocol.Version;
+}
+/**
+ * Applies function f on protocol version of a protocol
+ */
+export function Protocol_mapVersion(f, protocol) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, map(f, protocol.Version), protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Replaces protocol version of a protocol by given protocol version
+ */
+export function Protocol_setVersion(protocol, version) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Protocol Name
+ * Returns protocol name of a protocol
+ */
+export function Protocol_getName_3BF20962(protocol) {
+    return protocol.Name;
+}
+/**
+ * Applies function f on protocol name of a protocol
+ */
+export function Protocol_mapName(f, protocol) {
+    return new Protocol(protocol.ID, map(f, protocol.Name), protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Replaces protocol name of a protocol by given protocol name
+ */
+export function Protocol_setName(protocol, name) {
+    return new Protocol(protocol.ID, name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Returns protocol description of a protocol
+ */
+export function Protocol_getDescription_3BF20962(protocol) {
+    return protocol.Description;
+}
+/**
+ * Applies function f on protocol description of a protocol
+ */
+export function Protocol_mapDescription(f, protocol) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, map(f, protocol.Description), protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Replaces protocol description of a protocol by given protocol description
+ */
+export function Protocol_setDescription(protocol, description) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, description, protocol.Uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Returns protocol URI of a protocol
+ */
+export function Protocol_getUri_3BF20962(protocol) {
+    return protocol.Uri;
+}
+/**
+ * Applies function f on protocol URI of a protocol
+ */
+export function Protocol_mapUri(f, protocol) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, map(f, protocol.Uri), protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Replaces protocol URI of a protocol by given protocol URI
+ */
+export function Protocol_setUri(protocol, uri) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, uri, protocol.Version, protocol.Parameters, protocol.Components, protocol.Comments);
+}
+/**
+ * Returns components of a protocol
+ */
+export function Protocol_getComponents_3BF20962(protocol) {
+    return protocol.Components;
+}
+/**
+ * Applies function f on components of a protocol
+ */
+export function Protocol_mapComponents(f, protocol) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, map(f, protocol.Components), protocol.Comments);
+}
+/**
+ * Replaces components of a protocol by given component list
+ */
+export function Protocol_setComponents(protocol, components) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, protocol.Parameters, components, protocol.Comments);
+}
+export function Protocol_addComponent(comp, protocol) {
+    return Protocol_setComponents(protocol, append(defaultArg(protocol.Components, empty()), singleton(comp)));
+}
+/**
+ * Returns protocol parameters of a protocol
+ */
+export function Protocol_getParameters_3BF20962(protocol) {
+    return protocol.Parameters;
+}
+/**
+ * Applies function f on protocol parameters of a protocol
+ */
+export function Protocol_mapParameters(f, protocol) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, map(f, protocol.Parameters), protocol.Components, protocol.Comments);
+}
+/**
+ * Replaces protocol parameters of a protocol by given protocol parameter list
+ */
+export function Protocol_setParameters(protocol, parameters) {
+    return new Protocol(protocol.ID, protocol.Name, protocol.ProtocolType, protocol.Description, protocol.Uri, protocol.Version, parameters, protocol.Components, protocol.Comments);
+}
+export function Protocol_addParameter(parameter, protocol) {
+    return Protocol_setParameters(protocol, append(defaultArg(protocol.Parameters, empty()), singleton(parameter)));
+}

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

@@ -0,0 +1,70 @@
+import { bind, map, defaultArg, unwrap } from "@fable-org/fable-library-js/Option.js";
+import { OntologyAnnotation_$reflection, OntologyAnnotation } from "../OntologyAnnotation.js";
+import { Option_fromValueWithDefault } from "../Helper/Collections.js";
+import { Record, toString } from "@fable-org/fable-library-js/Types.js";
+import { record_type, option_type, string_type } from "@fable-org/fable-library-js/Reflection.js";
+export class ProtocolParameter extends Record {
+    constructor(ID, ParameterName) {
+        super();
+        this.ID = ID;
+        this.ParameterName = ParameterName;
+    }
+    static make(id, parameterName) {
+        return new ProtocolParameter(id, parameterName);
+    }
+    static create(Id, ParameterName) {
+        return ProtocolParameter.make(Id, ParameterName);
+    }
+    static get empty() {
+        return ProtocolParameter.create();
+    }
+    static fromString(term, source, accession, comments) {
+        const oa = OntologyAnnotation.create(term, source, accession, unwrap(comments));
+        const parameterName = Option_fromValueWithDefault(new OntologyAnnotation(), oa);
+        return ProtocolParameter.make(undefined, parameterName);
+    }
+    static toStringObject(pp) {
+        const value = {
+            TermAccessionNumber: "",
+            TermName: "",
+            TermSourceREF: "",
+        };
+        return defaultArg(map((oa) => OntologyAnnotation.toStringObject(oa), pp.ParameterName), value);
+    }
+    get NameText() {
+        const this$ = this;
+        return defaultArg(map((oa) => oa.NameText, this$.ParameterName), "");
+    }
+    get TryNameText() {
+        const this$ = this;
+        return unwrap(bind((oa) => oa.Name, this$.ParameterName));
+    }
+    MapCategory(f) {
+        const this$ = this;
+        return new ProtocolParameter(this$.ID, map(f, this$.ParameterName));
+    }
+    SetCategory(c) {
+        const this$ = this;
+        return new ProtocolParameter(this$.ID, c);
+    }
+    static tryGetNameText(pp) {
+        return pp.TryNameText;
+    }
+    static getNameText(pp) {
+        return defaultArg(ProtocolParameter.tryGetNameText(pp), "");
+    }
+    static nameEqualsString(name, pp) {
+        return pp.NameText === name;
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        const this$ = this;
+        return "OA " + this$.NameText;
+    }
+}
+export function ProtocolParameter_$reflection() {
+    return record_type("ARCtrl.Process.ProtocolParameter", [], ProtocolParameter, () => [["ID", option_type(string_type)], ["ParameterName", option_type(OntologyAnnotation_$reflection())]]);
+}

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

@@ -0,0 +1,59 @@
+import { Record, toString } from "@fable-org/fable-library-js/Types.js";
+import { append, choose, empty, length } from "@fable-org/fable-library-js/List.js";
+import { defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { MaterialAttributeValue_$reflection } from "./MaterialAttributeValue.js";
+import { FactorValue_$reflection } from "./FactorValue.js";
+import { printf, toText } from "@fable-org/fable-library-js/String.js";
+import { Source_$reflection } from "./Source.js";
+import { record_type, list_type, option_type, string_type } from "@fable-org/fable-library-js/Reflection.js";
+export class Sample extends Record {
+    constructor(ID, Name, Characteristics, FactorValues, DerivesFrom) {
+        super();
+        this.ID = ID;
+        this.Name = Name;
+        this.Characteristics = Characteristics;
+        this.FactorValues = FactorValues;
+        this.DerivesFrom = DerivesFrom;
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        const this$ = this;
+        const chars = length(defaultArg(this$.Characteristics, empty())) | 0;
+        const facts = length(defaultArg(this$.FactorValues, empty())) | 0;
+        const arg = Sample__get_NameAsString(this$);
+        return toText(printf("%s [%i characteristics; %i factors]"))(arg)(chars)(facts);
+    }
+}
+export function Sample_$reflection() {
+    return record_type("ARCtrl.Process.Sample", [], Sample, () => [["ID", option_type(string_type)], ["Name", option_type(string_type)], ["Characteristics", option_type(list_type(MaterialAttributeValue_$reflection()))], ["FactorValues", option_type(list_type(FactorValue_$reflection()))], ["DerivesFrom", option_type(list_type(Source_$reflection()))]]);
+}
+export function Sample_make(id, name, characteristics, factorValues, derivesFrom) {
+    return new Sample(id, name, characteristics, factorValues, derivesFrom);
+}
+export function Sample_create_62424AD2(Id, Name, Characteristics, FactorValues, DerivesFrom) {
+    return Sample_make(Id, Name, Characteristics, FactorValues, DerivesFrom);
+}
+export function Sample_get_empty() {
+    return Sample_create_62424AD2();
+}
+export function Sample__get_NameAsString(this$) {
+    return defaultArg(this$.Name, "");
+}
+export function Sample_getCharacteristicUnits_53716792(s) {
+    return choose((c) => c.Unit, defaultArg(s.Characteristics, empty()));
+}
+export function Sample_getFactorUnits_53716792(s) {
+    return choose((c) => c.Unit, defaultArg(s.FactorValues, empty()));
+}
+export function Sample_getUnits_53716792(s) {
+    return append(Sample_getCharacteristicUnits_53716792(s), Sample_getFactorUnits_53716792(s));
+}
+export function Sample_setCharacteristicValues(values, s) {
+    return new Sample(s.ID, s.Name, values, s.FactorValues, s.DerivesFrom);
+}
+export function Sample_setFactorValues(values, s) {
+    return new Sample(s.ID, s.Name, s.Characteristics, values, s.DerivesFrom);
+}

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

@@ -0,0 +1,45 @@
+import { Record, toString } from "@fable-org/fable-library-js/Types.js";
+import { choose, empty, length } from "@fable-org/fable-library-js/List.js";
+import { defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { MaterialAttributeValue_$reflection } from "./MaterialAttributeValue.js";
+import { printf, toText } from "@fable-org/fable-library-js/String.js";
+import { record_type, list_type, option_type, string_type } from "@fable-org/fable-library-js/Reflection.js";
+export class Source extends Record {
+    constructor(ID, Name, Characteristics) {
+        super();
+        this.ID = ID;
+        this.Name = Name;
+        this.Characteristics = Characteristics;
+    }
+    Print() {
+        const this$ = this;
+        return toString(this$);
+    }
+    PrintCompact() {
+        const this$ = this;
+        const l = length(defaultArg(this$.Characteristics, empty())) | 0;
+        const arg = Source__get_NameAsString(this$);
+        return toText(printf("%s [%i characteristics]"))(arg)(l);
+    }
+}
+export function Source_$reflection() {
+    return record_type("ARCtrl.Process.Source", [], Source, () => [["ID", option_type(string_type)], ["Name", option_type(string_type)], ["Characteristics", option_type(list_type(MaterialAttributeValue_$reflection()))]]);
+}
+export function Source_make(id, name, characteristics) {
+    return new Source(id, name, characteristics);
+}
+export function Source_create_Z5CA08497(Id, Name, Characteristics) {
+    return Source_make(Id, Name, Characteristics);
+}
+export function Source_get_empty() {
+    return Source_create_Z5CA08497();
+}
+export function Source__get_NameAsString(this$) {
+    return defaultArg(this$.Name, "");
+}
+export function Source_getUnits_53E41069(m) {
+    return choose((c) => c.Unit, defaultArg(m.Characteristics, empty()));
+}
+export function Source_setCharacteristicValues(values, m) {
+    return new Source(m.ID, m.Name, values);
+}