@nfdi4plants/arctrl 2.3.1 → 2.5.0

package/ROCrate/Generic/LabProtocol.js

@@ -0,0 +1,275 @@
+import { value, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { LDDefinedTerm } from "./DefinedTerm.js";
+import { LDComment } from "./Comment.js";
+import { empty, singleton as singleton_1, delay, toList, append } from "../../fable_modules/fable-library-js.4.24.0/Seq.js";
+import { clean } from "../Helper.js";
+import { join } from "../../fable_modules/fable-library-js.4.24.0/String.js";
+import { isEmpty, singleton, append as append_1 } from "../../fable_modules/fable-library-js.4.24.0/List.js";
+import { createMissingIdentifier } from "../../Core/Helper/Identifier.js";
+import { LDNode } from "../LDObject.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDLabProtocol {
+    constructor() {
+    }
+    static get schemaType() {
+        return "https://bioschemas.org/LabProtocol";
+    }
+    static get description() {
+        return "http://schema.org/description";
+    }
+    static get intendedUse() {
+        return "https://bioschemas.org/intendedUse";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static get comment() {
+        return "http://schema.org/comment";
+    }
+    static get computationalTool() {
+        return "https://bioschemas.org/computationalTool";
+    }
+    static get labEquipment() {
+        return "https://bioschemas.org/labEquipment";
+    }
+    static get reagent() {
+        return "https://bioschemas.org/reagent";
+    }
+    static get url() {
+        return "http://schema.org/url";
+    }
+    static get version() {
+        return "http://schema.org/version";
+    }
+    static tryGetDescriptionAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.description, unwrap(context));
+        let matchResult, d;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                d = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return d;
+            default:
+                return undefined;
+        }
+    }
+    static setDescriptionAsString(lp, description, context) {
+        return lp.SetProperty(LDLabProtocol.description, description, unwrap(context));
+    }
+    static tryGetIntendedUseAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.intendedUse, unwrap(context));
+        let matchResult, iu;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                iu = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return iu;
+            default:
+                return undefined;
+        }
+    }
+    static setIntendedUseAsString(lp, intendedUse, context) {
+        return lp.SetProperty(LDLabProtocol.intendedUse, intendedUse, unwrap(context));
+    }
+    static tryGetIntendedUseAsDefinedTerm(lp, graph, context) {
+        let ldObject;
+        const matchValue = lp.TryGetPropertyAsSingleNode(LDLabProtocol.intendedUse, unwrap(graph), unwrap(context));
+        let matchResult, iu_1;
+        if (matchValue != null) {
+            if ((ldObject = matchValue, LDDefinedTerm.validate(ldObject, unwrap(context)))) {
+                matchResult = 0;
+                iu_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return iu_1;
+            default:
+                return undefined;
+        }
+    }
+    static setIntendedUseAsDefinedTerm(lp, intendedUse, context) {
+        return lp.SetProperty(LDLabProtocol.intendedUse, intendedUse, unwrap(context));
+    }
+    static tryGetNameAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.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(LDLabProtocol.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:
+                throw new Error(`Could not access property \`name\` of object with @id \`${lp.Id}\``);
+        }
+    }
+    static setNameAsString(lp, name, context) {
+        return lp.SetProperty(LDLabProtocol.name, name, unwrap(context));
+    }
+    static getComments(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProtocol.comment, (ldObject, context_1) => LDComment.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setComments(lp, comments, context) {
+        return lp.SetProperty(LDLabProtocol.comment, comments, unwrap(context));
+    }
+    static getComputationalTools(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProtocol.computationalTool, undefined, unwrap(graph), unwrap(context));
+    }
+    static setComputationalTools(lp, computationalTools, context) {
+        return lp.SetProperty(LDLabProtocol.computationalTool, computationalTools, unwrap(context));
+    }
+    static getLabEquipments(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProtocol.labEquipment, undefined, unwrap(graph), unwrap(context));
+    }
+    static setLabEquipments(lp, labEquipments, context) {
+        return lp.SetProperty(LDLabProtocol.labEquipment, labEquipments, unwrap(context));
+    }
+    static getReagents(lp, graph, context) {
+        return lp.GetPropertyNodes(LDLabProtocol.reagent, undefined, unwrap(graph), unwrap(context));
+    }
+    static setReagents(lp, reagents, context) {
+        return lp.SetProperty(LDLabProtocol.reagent, reagents, unwrap(context));
+    }
+    static getComponents(lp, graph, context) {
+        let collection;
+        let source_3;
+        const source_1 = LDLabProtocol.getLabEquipments(lp, unwrap(graph), unwrap(context));
+        source_3 = append(LDLabProtocol.getReagents(lp, unwrap(graph), unwrap(context)), source_1);
+        collection = append(LDLabProtocol.getComputationalTools(lp, unwrap(graph), unwrap(context)), source_3);
+        return Array.from(collection);
+    }
+    static tryGetUrl(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.url, unwrap(context));
+        let matchResult, u;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                u = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return u;
+            default:
+                return undefined;
+        }
+    }
+    static setUrl(lp, url, context) {
+        return lp.SetProperty(LDLabProtocol.url, url, unwrap(context));
+    }
+    static tryGetVersionAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.version, unwrap(context));
+        let matchResult, v;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                v = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return v;
+            default:
+                return undefined;
+        }
+    }
+    static setVersionAsString(lp, version, context) {
+        return lp.SetProperty(LDLabProtocol.version, version, unwrap(context));
+    }
+    static validate(lp, context) {
+        return lp.HasType(LDLabProtocol.schemaType, unwrap(context));
+    }
+    static genId(name, processName, assayName, studyName) {
+        let vals;
+        return clean(join("_", append_1(singleton("#Protocol"), (vals = toList(delay(() => append((name != null) ? singleton_1(value(name)) : empty(), delay(() => append((processName != null) ? singleton_1(value(processName)) : empty(), delay(() => append((assayName != null) ? singleton_1(value(assayName)) : empty(), delay(() => ((studyName != null) ? singleton_1(value(studyName)) : empty()))))))))), isEmpty(vals) ? singleton(createMissingIdentifier()) : vals))));
+    }
+    static create(id, name, description, intendedUse, comments, computationalTools, labEquipments, reagents, url, version, context) {
+        const lp = new LDNode(id, [LDLabProtocol.schemaType], undefined, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.name, name, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.description, description, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.intendedUse, intendedUse, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.comment, comments, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.computationalTool, computationalTools, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.labEquipment, labEquipments, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.reagent, reagents, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.url, url, unwrap(context));
+        lp.SetOptionalProperty(LDLabProtocol.version, version, unwrap(context));
+        return lp;
+    }
+}
+
+export function LDLabProtocol_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDLabProtocol", undefined, LDLabProtocol);
+}
+

package/ROCrate/Generic/Organization.js

@@ -0,0 +1,71 @@
+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 LDOrganization {
+    constructor() {
+    }
+    static get schemaType() {
+        return "http://schema.org/Organization";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static tryGetNameAsString(o, context) {
+        const matchValue = o.TryGetPropertyAsSingleton(LDOrganization.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(o, context) {
+        const matchValue = o.TryGetPropertyAsSingleton(LDOrganization.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 \`${o.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`name\` of object with @id \`${o.Id}\``);
+        }
+    }
+    static setNameAsString(o, n, context) {
+        return o.SetProperty(LDOrganization.name, n, unwrap(context));
+    }
+    static genID(name) {
+        return clean(`#Organization_${name}`);
+    }
+    static validate(o, context) {
+        return o.HasType(LDOrganization.schemaType, unwrap(context)) && o.HasProperty(LDOrganization.name, unwrap(context));
+    }
+    static create(name, id, context) {
+        const o = new LDNode((id == null) ? LDOrganization.genID(name) : id, [LDOrganization.schemaType], undefined, unwrap(context));
+        o.SetProperty(LDOrganization.name, name, unwrap(context));
+        return o;
+    }
+}
+
+export function LDOrganization_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDOrganization", undefined, LDOrganization);
+}
+