@nfdi4plants/arctrl 2.3.1 → 2.5.0

package/ROCrate/Generic/DefinedTerm.js

@@ -0,0 +1,115 @@
+import { value, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { clean } from "../Helper.js";
+import { LDNode } from "../LDObject.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDDefinedTerm {
+    constructor() {
+    }
+    static get schemaType() {
+        return "http://schema.org/DefinedTerm";
+    }
+    static get termCode() {
+        return "http://schema.org/termCode";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static tryGetTermCodeAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDDefinedTerm.termCode, unwrap(context));
+        let matchResult, tc;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                tc = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return tc;
+            default:
+                return undefined;
+        }
+    }
+    static getTermCodeAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDDefinedTerm.termCode, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                const tc = value(matchValue);
+                return tc;
+            }
+            else {
+                throw new Error(`Property of \`termCode\` of object with @id \`${dt.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`termCode\` of object with @id \`${dt.Id}\``);
+        }
+    }
+    static setTermCodeAsString(dt, termCode, context) {
+        return dt.SetProperty(LDDefinedTerm.termCode, termCode, unwrap(context));
+    }
+    static tryGetNameAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDDefinedTerm.name, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                n = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getNameAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDDefinedTerm.name, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                const n = value(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`Property of \`name\` of object with @id \`${dt.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`name\` of object with @id \`${dt.Id}\``);
+        }
+    }
+    static setNameAsString(dt, name, context) {
+        return dt.SetProperty(LDDefinedTerm.name, name, unwrap(context));
+    }
+    static genID(name, termCode) {
+        return (termCode == null) ? clean(`#OA_${name}`) : (`${termCode}`);
+    }
+    static validate(dt, context) {
+        return dt.HasType(LDDefinedTerm.schemaType, unwrap(context)) && dt.HasProperty(LDDefinedTerm.name, unwrap(context));
+    }
+    static create(name, id, termCode, context) {
+        const dt = new LDNode((id == null) ? LDDefinedTerm.genID(name, unwrap(termCode)) : id, [LDDefinedTerm.schemaType], undefined, unwrap(context));
+        dt.SetProperty(LDDefinedTerm.name, name, unwrap(context));
+        dt.SetOptionalProperty(LDDefinedTerm.termCode, termCode, unwrap(context));
+        return dt;
+    }
+}
+
+export function LDDefinedTerm_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDDefinedTerm", undefined, LDDefinedTerm);
+}
+

package/ROCrate/Generic/File.js

@@ -0,0 +1,200 @@
+import { value, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { LDComment } from "./Comment.js";
+import { LDDefinedTerm } from "./DefinedTerm.js";
+import { LDNode } from "../LDObject.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDFile {
+    constructor() {
+    }
+    static get schemaType() {
+        return "http://schema.org/MediaObject";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static get comment() {
+        return "http://schema.org/comment";
+    }
+    static get disambiguatingDescription() {
+        return "http://schema.org/disambiguatingDescription";
+    }
+    static get usageInfo() {
+        return "http://schema.org/usageInfo";
+    }
+    static get encodingFormat() {
+        return "http://schema.org/encodingFormat";
+    }
+    static get pattern() {
+        return "http://schema.org/pattern";
+    }
+    static get about() {
+        return "http://schema.org/about";
+    }
+    static tryGetNameAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDFile.name, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                n = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getNameAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDFile.name, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                const n = value(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`Property of \`name\` of object with @id \`${dt.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`name\` of object with @id \`${dt.Id}\``);
+        }
+    }
+    static setNameAsString(dt, name, context) {
+        return dt.SetProperty(LDFile.name, name, unwrap(context));
+    }
+    static getComments(dt, graph, context) {
+        return dt.GetPropertyNodes(LDFile.comment, (ldObject, context_1) => LDComment.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setComments(dt, comment, context) {
+        return dt.SetProperty(LDFile.comment, comment, unwrap(context));
+    }
+    static tryGetDisambiguatingDescriptionAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDFile.disambiguatingDescription, unwrap(context));
+        let matchResult, dd;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                dd = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return dd;
+            default:
+                return undefined;
+        }
+    }
+    static setDisambiguatingDescriptionAsString(dt, disambiguatingDescription, context) {
+        return dt.SetProperty(LDFile.disambiguatingDescription, disambiguatingDescription, unwrap(context));
+    }
+    static tryGetEncodingFormatAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDFile.encodingFormat, unwrap(context));
+        let matchResult, ef;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                ef = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return ef;
+            default:
+                return undefined;
+        }
+    }
+    static setEncodingFormatAsString(dt, encodingFormat, context) {
+        return dt.SetProperty(LDFile.encodingFormat, encodingFormat, unwrap(context));
+    }
+    static tryGetUsageInfoAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDFile.usageInfo, unwrap(context));
+        let matchResult, ui;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                ui = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return ui;
+            default:
+                return undefined;
+        }
+    }
+    static setUsageInfoAsString(dt, usageInfo, context) {
+        return dt.SetProperty(LDFile.usageInfo, usageInfo, unwrap(context));
+    }
+    static tryGetPatternAsDefinedTerm(dt, graph, context) {
+        let dt_1;
+        const matchValue = dt.TryGetPropertyAsSingleNode(LDFile.pattern, unwrap(graph), unwrap(context));
+        if (matchValue != null) {
+            if ((dt_1 = matchValue, LDDefinedTerm.validate(dt_1, unwrap(context)))) {
+                const dt_2 = matchValue;
+                return dt_2;
+            }
+            else {
+                throw new Error(`Property of \`pattern\` of object with @id \`${dt.Id}\` was not a DefinedTerm`);
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    static setPatternAsDefinedTerm(dt, pattern, context) {
+        return dt.SetProperty(LDFile.pattern, pattern, unwrap(context));
+    }
+    static tryGetAbout(dt, graph, context) {
+        return dt.TryGetPropertyAsSingleNode(LDFile.about, unwrap(graph), unwrap(context));
+    }
+    static setAbout(dt, about, context) {
+        return dt.SetProperty(LDFile.about, about, unwrap(context));
+    }
+    static genId(name) {
+        return `${name}`;
+    }
+    static validate(dt, context) {
+        return dt.HasType(LDFile.schemaType, unwrap(context)) && dt.HasProperty(LDFile.name, unwrap(context));
+    }
+    static create(name, id, comments, disambiguatingDescription, encodingFormat, usageInfo, context) {
+        const dt = new LDNode((id == null) ? LDFile.genId(name) : id, [LDFile.schemaType], undefined, unwrap(context));
+        dt.SetProperty(LDFile.name, name, unwrap(context));
+        dt.SetOptionalProperty(LDFile.comment, comments, unwrap(context));
+        dt.SetOptionalProperty(LDFile.disambiguatingDescription, disambiguatingDescription, unwrap(context));
+        dt.SetOptionalProperty(LDFile.encodingFormat, encodingFormat, unwrap(context));
+        dt.SetOptionalProperty(LDFile.usageInfo, usageInfo, unwrap(context));
+        return dt;
+    }
+}
+
+export function LDFile_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDFile", undefined, LDFile);
+}
+

package/ROCrate/Generic/LabProcess.js

@@ -0,0 +1,238 @@
+import { defaultArg, value, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { LDPerson } from "./Person.js";
+import { LDSample } from "./Sample.js";
+import { LDFile } from "./File.js";
+import { LDLabProtocol } from "./LabProtocol.js";
+import { LDPropertyValue } from "./PropertyValue.js";
+import { ResizeArray_map } from "../../Core/Helper/Collections.js";
+import { clean } from "../Helper.js";
+import { LDNode } from "../LDObject.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDLabProcess {
+    constructor() {
+    }
+    static get schemaType() {
+        return "https://bioschemas.org/LabProcess";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static get agent() {
+        return "http://schema.org/agent";
+    }
+    static get object_() {
+        return "http://schema.org/object";
+    }
+    static get result() {
+        return "http://schema.org/result";
+    }
+    static get executesLabProtocol() {
+        return "https://bioschemas.org/executesLabProtocol";
+    }
+    static get parameterValue() {
+        return "https://bioschemas.org/parameterValue";
+    }
+    static get endTime() {
+        return "http://schema.org/endTime";
+    }
+    static get disambiguatingDescription() {
+        return "http://schema.org/disambiguatingDescription";
+    }
+    static tryGetNameAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDLabProcess.name, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                n = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getNameAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDLabProcess.name, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                const n = value(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`property \`name\` of object with @id \`${lp.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`name\` of object with @id \`${lp.Id}\``);
+        }
+    }
+    static setNameAsString(lp, name, context) {
+        return lp.SetProperty(LDLabProcess.name, name, unwrap(context));
+    }
+    static tryGetAgent(lp, graph, context) {
+        let ldObject;
+        const matchValue = lp.TryGetPropertyAsSingleNode(LDLabProcess.agent, unwrap(graph), unwrap(context));
+        let matchResult, a_1;
+        if (matchValue != null) {
+            if ((ldObject = matchValue, LDPerson.validate(ldObject, unwrap(context)))) {
+                matchResult = 0;
+                a_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return a_1;
+            default:
+                return undefined;
+        }
+    }
+    static getAgent(lp, graph, context) {
+        let ldObject;
+        const matchValue = lp.TryGetPropertyAsSingleNode(LDLabProcess.agent, unwrap(graph), unwrap(context));
+        if (matchValue != null) {
+            if ((ldObject = matchValue, LDPerson.validate(ldObject, unwrap(context)))) {
+                const a_1 = matchValue;
+                return a_1;
+            }
+            else {
+                throw new Error(`Property of \`agent\` of object with @id \`${lp.Id}\` was not a valid Person`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`agent\` of object with @id \`${lp.Id}\``);
+        }
+    }
+    static setAgent(lp, agent, context) {
+        return lp.SetProperty(LDLabProcess.agent, agent, unwrap(context));
+    }
+    static getObjects(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProcess.object_, undefined, unwrap(graph), unwrap(context));
+    }
+    static getObjectsAsSample(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProcess.object_, (ldObject, context_1) => LDSample.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static getObjectsAsData(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProcess.object_, (ldObject, context_1) => LDFile.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setObjects(lp, objects, context) {
+        return lp.SetProperty(LDLabProcess.object_, objects, unwrap(context));
+    }
+    static getResults(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProcess.result, undefined, unwrap(graph), unwrap(context));
+    }
+    static getResultsAsSample(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProcess.result, (ldObject, context_1) => LDSample.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static getResultsAsData(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProcess.result, (ldObject, context_1) => LDFile.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setResults(lp, results, context) {
+        return lp.SetProperty(LDLabProcess.result, results, unwrap(context));
+    }
+    static tryGetExecutesLabProtocol(lp, graph, context) {
+        let ldObject;
+        const matchValue = lp.TryGetPropertyAsSingleNode(LDLabProcess.executesLabProtocol, unwrap(graph), unwrap(context));
+        let matchResult, l_1;
+        if (matchValue != null) {
+            if ((ldObject = matchValue, LDLabProtocol.validate(ldObject, unwrap(context)))) {
+                matchResult = 0;
+                l_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return l_1;
+            default:
+                return undefined;
+        }
+    }
+    static setExecutesLabProtocol(lp, executesLabProtocol, context) {
+        return lp.SetProperty(LDLabProcess.executesLabProtocol, executesLabProtocol, unwrap(context));
+    }
+    static getParameterValues(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProcess.parameterValue, (ldObject, context_1) => LDPropertyValue.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setParameterValues(lp, parameterValues, context) {
+        return lp.SetProperty(LDLabProcess.parameterValue, parameterValues, unwrap(context));
+    }
+    static tryGetEndTime(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDLabProcess.endTime, unwrap(context));
+        let matchResult, et;
+        if (matchValue != null) {
+            if (value(matchValue) instanceof Date) {
+                matchResult = 0;
+                et = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return et;
+            default:
+                return undefined;
+        }
+    }
+    static setEndTime(lp, endTime, context) {
+        return lp.SetProperty(LDLabProcess.endTime, endTime, unwrap(context));
+    }
+    static getDisambiguatingDescriptionsAsString(lp, context) {
+        return ResizeArray_map((o_1) => o_1, lp.GetPropertyValues(LDLabProcess.disambiguatingDescription, (o, context_1) => (typeof o === "string"), unwrap(context)));
+    }
+    static setDisambiguatingDescriptionsAsString(lp, disambiguatingDescriptions, context) {
+        return lp.SetProperty(LDLabProcess.disambiguatingDescription, disambiguatingDescriptions, unwrap(context));
+    }
+    static validate(lp, context) {
+        return lp.HasType(LDLabProcess.schemaType, unwrap(context)) && lp.HasProperty(LDLabProcess.name, unwrap(context));
+    }
+    static genId(name, assayName, studyName) {
+        let study_1, assay_1, assay, study;
+        return clean((assayName == null) ? ((studyName != null) ? ((study_1 = value(studyName), `#Process_${study_1}_${name}`)) : (`#Process_${name}`)) : ((studyName == null) ? ((assay_1 = value(assayName), `#Process_${assay_1}_${name}`)) : ((assay = value(assayName), (study = value(studyName), `#Process_${study}_${assay}_${name}`)))));
+    }
+    static create(name, objects, results, id, agent, executesLabProtocol, parameterValues, endTime, disambiguatingDescriptions, context) {
+        const id_1 = (id == null) ? LDLabProcess.genId(name) : id;
+        const objects_1 = defaultArg(objects, []);
+        const results_1 = defaultArg(results, []);
+        const lp = new LDNode(id_1, [LDLabProcess.schemaType], undefined, unwrap(context));
+        lp.SetProperty(LDLabProcess.name, name, unwrap(context));
+        lp.SetOptionalProperty(LDLabProcess.agent, agent, unwrap(context));
+        lp.SetProperty(LDLabProcess.object_, objects_1, unwrap(context));
+        lp.SetProperty(LDLabProcess.result, results_1, unwrap(context));
+        lp.SetOptionalProperty(LDLabProcess.executesLabProtocol, executesLabProtocol, unwrap(context));
+        lp.SetOptionalProperty(LDLabProcess.parameterValue, parameterValues, unwrap(context));
+        lp.SetOptionalProperty(LDLabProcess.endTime, endTime, unwrap(context));
+        lp.SetOptionalProperty(LDLabProcess.disambiguatingDescription, disambiguatingDescriptions, unwrap(context));
+        return lp;
+    }
+}
+
+export function LDLabProcess_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDLabProcess", undefined, LDLabProcess);
+}
+