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

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

@@ -0,0 +1,103 @@
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { clean } from '../Helper.js';
+
+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 void 0;
+    }
+  }
+  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 void 0;
+    }
+  }
+  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], void 0, unwrap(context));
+    dt.SetProperty(LDDefinedTerm.name, name, unwrap(context));
+    dt.SetOptionalProperty(LDDefinedTerm.termCode, termCode, unwrap(context));
+    return dt;
+  }
+}
+
+export { LDDefinedTerm };

package/dist/ts/ts/ROCrate/Generic/File.js

@@ -0,0 +1,184 @@
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { LDComment } from './Comment.js';
+import { LDDefinedTerm } from './DefinedTerm.js';
+
+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 void 0;
+    }
+  }
+  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 void 0;
+    }
+  }
+  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 void 0;
+    }
+  }
+  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 void 0;
+    }
+  }
+  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 void 0;
+    }
+  }
+  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], void 0, 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 { LDFile };

package/dist/ts/ts/ROCrate/Generic/LabProcess.js

@@ -0,0 +1,222 @@
+import { unwrap, value, defaultArg } from '../../../node_modules/@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';
+
+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 void 0;
+    }
+  }
+  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 void 0;
+    }
+  }
+  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_, void 0, 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, void 0, 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 void 0;
+    }
+  }
+  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 void 0;
+    }
+  }
+  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], void 0, 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 { LDLabProcess };