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

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

@@ -1,112 +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 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}`) : (`${value(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)) : value(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/dist/ts/esm/ts/ROCrate/Generic/File.js

@@ -1,197 +0,0 @@
-import { value, unwrap } from "@fable-org/fable-library-js/Option.js";
-import { LDNode } from "../LDObject.js";
-import { LDComment } from "./Comment.js";
-import { LDDefinedTerm } from "./DefinedTerm.js";
-import { class_type } from "@fable-org/fable-library-js/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 = value(matchValue), LDDefinedTerm.validate(dt_1, unwrap(context)))) {
-                const dt_2 = value(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) : value(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/dist/ts/esm/ts/ROCrate/Generic/LabProcess.js

@@ -1,235 +0,0 @@
-import { defaultArg, value, unwrap } from "@fable-org/fable-library-js/Option.js";
-import { LDNode } from "../LDObject.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 { class_type } from "@fable-org/fable-library-js/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 = value(matchValue), LDPerson.validate(ldObject, unwrap(context)))) {
-                matchResult = 0;
-                a_1 = value(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 = value(matchValue), LDPerson.validate(ldObject, unwrap(context)))) {
-                const a_1 = value(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 = value(matchValue), LDLabProtocol.validate(ldObject, unwrap(context)))) {
-                matchResult = 0;
-                l_1 = value(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_S_${study_1}_${name}`)) : (`#Process_${name}`)) : ((studyName == null) ? ((assay_1 = value(assayName), `#Process_A_${assay_1}_${name}`)) : ((assay = value(assayName), (study = value(studyName), `#Process_S_${study}_A_${assay}_${name}`)))));
-    }
-    static create(name, objects, results, id, agent, executesLabProtocol, parameterValues, endTime, disambiguatingDescriptions, context) {
-        const id_1 = (id == null) ? LDLabProcess.genId(name) : value(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);
-}