@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/ts/esm/ts/ROCrate/Generic/LabProtocol.js

@@ -1,272 +0,0 @@
-import { value, unwrap } from "@fable-org/fable-library-js/Option.js";
-import { LDNode } from "../LDObject.js";
-import { LDDefinedTerm } from "./DefinedTerm.js";
-import { LDComment } from "./Comment.js";
-import { empty, singleton as singleton_1, delay, toList, append } from "@fable-org/fable-library-js/Seq.js";
-import { clean } from "../Helper.js";
-import { join } from "@fable-org/fable-library-js/String.js";
-import { isEmpty, singleton, append as append_1 } from "@fable-org/fable-library-js/List.js";
-import { createMissingIdentifier } from "../../Core/Helper/Identifier.js";
-import { class_type } from "@fable-org/fable-library-js/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 = value(matchValue), LDDefinedTerm.validate(ldObject, unwrap(context)))) {
-                matchResult = 0;
-                iu_1 = value(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/dist/ts/esm/ts/ROCrate/Generic/Organization.js

@@ -1,68 +0,0 @@
-import { value, unwrap } from "@fable-org/fable-library-js/Option.js";
-import { LDNode } from "../LDObject.js";
-import { clean } from "../Helper.js";
-import { class_type } from "@fable-org/fable-library-js/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) : value(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);
-}