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

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

@@ -0,0 +1,624 @@
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { LDPerson } from './Person.js';
+import { LDFile } from './File.js';
+import { LDScholarlyArticle } from './ScholarlyArticle.js';
+import { LDComment } from './Comment.js';
+import { LDLabProcess } from './LabProcess.js';
+import { LDDefinedTerm } from './DefinedTerm.js';
+import { LDPropertyValue } from './PropertyValue.js';
+import { ResizeArray_tryPick } from '../../Core/Helper/Collections.js';
+import { contains } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { stringHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+
+class LDDataset {
+  constructor() {
+  }
+  static get schemaType() {
+    return "http://schema.org/Dataset";
+  }
+  static get identifier() {
+    return "http://schema.org/identifier";
+  }
+  static get creator() {
+    return "http://schema.org/creator";
+  }
+  static get dateCreated() {
+    return "http://schema.org/dateCreated";
+  }
+  static get datePublished() {
+    return "http://schema.org/datePublished";
+  }
+  static get sdDatePublished() {
+    return "http://schema.org/datePublished";
+  }
+  static get license() {
+    return "http://schema.org/license";
+  }
+  static get dateModified() {
+    return "http://schema.org/dateModified";
+  }
+  static get description() {
+    return "http://schema.org/description";
+  }
+  static get hasPart() {
+    return "http://schema.org/hasPart";
+  }
+  static get headline() {
+    return "http://schema.org/headline";
+  }
+  static get name() {
+    return "http://schema.org/name";
+  }
+  static get citation() {
+    return "http://schema.org/citation";
+  }
+  static get comment() {
+    return "http://schema.org/comment";
+  }
+  static get mentions() {
+    return "http://schema.org/mentions";
+  }
+  static get url() {
+    return "http://schema.org/url";
+  }
+  static get about() {
+    return "http://schema.org/about";
+  }
+  static get measurementMethod() {
+    return "http://schema.org/measurementMethod";
+  }
+  static get measurementTechnique() {
+    return "http://schema.org/measurementTechnique";
+  }
+  static get variableMeasured() {
+    return "http://schema.org/variableMeasured";
+  }
+  static tryGetIdentifierAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.identifier, 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 getIdentifierAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.identifier, unwrap(context));
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        const n = value(matchValue);
+        return n;
+      } else {
+        throw new Error(`property \`identifier\` of object with @id \`${lp.Id}\` was not a string`);
+      }
+    } else {
+      throw new Error(`Could not access property \`identifier\` of object with @id \`${lp.Id}\``);
+    }
+  }
+  static setIdentifierAsString(lp, identifier, context) {
+    return lp.SetProperty(LDDataset.identifier, identifier, unwrap(context));
+  }
+  static getCreators(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.creator, (p, ctx) => LDPerson.validate(p, unwrap(ctx)), unwrap(graph), unwrap(context));
+  }
+  static setCreators(lp, creators, context) {
+    return lp.SetProperty(LDDataset.creator, creators, unwrap(context));
+  }
+  static tryGetDateCreatedAsDateTime(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.dateCreated, unwrap(context));
+    let matchResult, n;
+    if (matchValue != null) {
+      if (value(matchValue) instanceof Date) {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  static setDateCreatedAsDateTime(lp, dateCreated, context) {
+    return lp.SetProperty(LDDataset.dateCreated, dateCreated, unwrap(context));
+  }
+  static tryGetDatePublishedAsDateTime(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.datePublished, unwrap(context));
+    let matchResult, n;
+    if (matchValue != null) {
+      if (value(matchValue) instanceof Date) {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  static setDatePublishedAsDateTime(lp, datePublished, context) {
+    return lp.SetProperty(LDDataset.datePublished, datePublished, unwrap(context));
+  }
+  static tryGetSDDatePublishedAsDateTime(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.sdDatePublished, unwrap(context));
+    let matchResult, n;
+    if (matchValue != null) {
+      if (value(matchValue) instanceof Date) {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  static setSDDatePublishedAsDateTime(lp, sdDatePublished, context) {
+    return lp.SetProperty(LDDataset.sdDatePublished, sdDatePublished, unwrap(context));
+  }
+  static tryGetLicenseAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.license, 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 setLicenseAsString(lp, license, context) {
+    return lp.SetProperty(LDDataset.license, license, unwrap(context));
+  }
+  static setLicenseAsCreativeWork(lp, license, context) {
+    return lp.SetProperty(LDDataset.license, license, unwrap(context));
+  }
+  static tryGetDateModifiedAsDateTime(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.dateModified, unwrap(context));
+    let matchResult, n;
+    if (matchValue != null) {
+      if (value(matchValue) instanceof Date) {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  static setDateModifiedAsDateTime(lp, dateModified, context) {
+    return lp.SetProperty(LDDataset.dateModified, dateModified, unwrap(context));
+  }
+  static tryGetDescriptionAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.description, 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 getDescriptionAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.description, unwrap(context));
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        const n = value(matchValue);
+        return n;
+      } else {
+        throw new Error(`property \`description\` of object with @id \`${lp.Id}\` was not a string`);
+      }
+    } else {
+      throw new Error(`Could not access property \`description\` of object with @id \`${lp.Id}\``);
+    }
+  }
+  static setDescriptionAsString(lp, description, context) {
+    return lp.SetProperty(LDDataset.description, description, unwrap(context));
+  }
+  static getHasParts(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.hasPart, void 0, unwrap(graph), unwrap(context));
+  }
+  static getHasPartsAsDataset(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.hasPart, (ldnode, context_1) => LDDataset.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static getHasPartsAsFile(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.hasPart, (ldnode, context_1) => LDFile.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setHasParts(lp, hasParts, context) {
+    return lp.SetProperty(LDDataset.hasPart, hasParts, unwrap(context));
+  }
+  static tryGetHeadlineAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.headline, 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 tryGetNameAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.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(LDDataset.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(LDDataset.name, name, unwrap(context));
+  }
+  static getCitations(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.citation, (ldnode, context_1) => LDScholarlyArticle.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setCitations(lp, citations, context) {
+    return lp.SetProperty(LDDataset.citation, citations, unwrap(context));
+  }
+  static getComments(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.comment, (ldnode, context_1) => LDComment.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setComments(lp, comments, context) {
+    return lp.SetProperty(LDDataset.comment, comments, unwrap(context));
+  }
+  static tryGetUrlAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.url, 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 getUrlAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.url, unwrap(context));
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        const n = value(matchValue);
+        return n;
+      } else {
+        throw new Error(`property \`url\` of object with @id \`${lp.Id}\` was not a string`);
+      }
+    } else {
+      throw new Error(`Could not access property \`url\` of object with @id \`${lp.Id}\``);
+    }
+  }
+  static setUrlAsString(lp, url, context) {
+    return lp.SetProperty(LDDataset.url, url, unwrap(context));
+  }
+  static getAbouts(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.about, void 0, unwrap(graph), unwrap(context));
+  }
+  static getAboutsAsLabProcess(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.about, (ldnode, context_1) => LDLabProcess.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setAbouts(lp, abouts, context) {
+    return lp.SetProperty(LDDataset.about, abouts, unwrap(context));
+  }
+  static tryGetMeasurementMethodAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.measurementMethod, 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 tryGetMeasurementMethodAsDefinedTerm(lp, graph, context) {
+    let n;
+    const matchValue = lp.TryGetPropertyAsSingleNode(LDDataset.measurementMethod, unwrap(graph), unwrap(context));
+    let matchResult, n_1;
+    if (matchValue != null) {
+      if (n = value(matchValue), LDDefinedTerm.validate(n, unwrap(context))) {
+        matchResult = 0;
+        n_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n_1;
+      default:
+        return void 0;
+    }
+  }
+  static setMeasurementMethodAsString(lp, measurementMethod, context) {
+    return lp.SetProperty(LDDataset.measurementMethod, measurementMethod, unwrap(context));
+  }
+  static setMeasurementMethodAsDefinedTerm(lp, measurementMethod, context) {
+    return lp.SetProperty(LDDataset.measurementMethod, measurementMethod, unwrap(context));
+  }
+  static tryGetMeasurementTechniqueAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.measurementTechnique, 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 tryGetMeasurementTechniqueAsDefinedTerm(lp, graph, context) {
+    let n;
+    const matchValue = lp.TryGetPropertyAsSingleNode(LDDataset.measurementTechnique, unwrap(graph), unwrap(context));
+    let matchResult, n_1;
+    if (matchValue != null) {
+      if (n = value(matchValue), LDDefinedTerm.validate(n, unwrap(context))) {
+        matchResult = 0;
+        n_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n_1;
+      default:
+        return void 0;
+    }
+  }
+  static setMeasurementTechniqueAsString(lp, measurementTechnique, context) {
+    return lp.SetProperty(LDDataset.measurementTechnique, measurementTechnique, unwrap(context));
+  }
+  static setMeasurementTechniqueAsDefinedTerm(lp, measurementTechnique, context) {
+    return lp.SetProperty(LDDataset.measurementTechnique, measurementTechnique, unwrap(context));
+  }
+  static tryGetVariableMeasuredAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.variableMeasured, 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 tryGetVariableMeasuredAsPropertyValue(lp, graph, context) {
+    let n;
+    const matchValue = lp.TryGetPropertyAsSingleNode(LDDataset.variableMeasured, unwrap(graph), unwrap(context));
+    let matchResult, n_1;
+    if (matchValue != null) {
+      if (n = value(matchValue), LDPropertyValue.validate(n, unwrap(context))) {
+        matchResult = 0;
+        n_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n_1;
+      default:
+        return void 0;
+    }
+  }
+  static tryGetVariableMeasuredAsMeasurementType(lp, graph, context) {
+    return ResizeArray_tryPick((n) => {
+      if (!LDPropertyValue.validateFragmentDescriptor(n, unwrap(context))) {
+        return n;
+      } else {
+        return void 0;
+      }
+    }, lp.GetPropertyNodes(LDDataset.variableMeasured, void 0, unwrap(graph), unwrap(context)));
+  }
+  static getVariableMeasuredAsFragmentDescriptors(lp, graph, context) {
+    return lp.GetPropertyNodes(LDDataset.variableMeasured, (ldnode, context_1) => LDPropertyValue.validateFragmentDescriptor(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setVariableMeasuredAsString(lp, variableMeasured, context) {
+    return lp.SetProperty(LDDataset.variableMeasured, variableMeasured, unwrap(context));
+  }
+  static setVariableMeasuredAsPropertyValue(lp, variableMeasured, context) {
+    return lp.SetProperty(LDDataset.variableMeasured, variableMeasured, unwrap(context));
+  }
+  static setVariableMeasuredAsPropertyValues(lp, variableMeasured, context) {
+    return lp.SetProperty(LDDataset.variableMeasured, variableMeasured, unwrap(context));
+  }
+  static genIDInvesigation() {
+    return "./";
+  }
+  static genIDStudy(identifier) {
+    return `studies/${identifier}/`;
+  }
+  static genIDAssay(identifier) {
+    return `assays/${identifier}/`;
+  }
+  static validate(lp, context) {
+    return lp.HasType(LDDataset.schemaType, unwrap(context));
+  }
+  static validateInvestigation(lp, context) {
+    return LDDataset.validate(lp, unwrap(context)) && contains("Investigation", lp.AdditionalType, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static validateStudy(lp, context) {
+    return LDDataset.validate(lp, unwrap(context)) && contains("Study", lp.AdditionalType, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static validateAssay(lp, context) {
+    return LDDataset.validate(lp, unwrap(context)) && contains("Assay", lp.AdditionalType, {
+      Equals: (x, y) => x === y,
+      GetHashCode: stringHash
+    });
+  }
+  static create(id, identier, creators, dateCreated, datePublished, dateModified, description, hasParts, name, citations, comments, mentions, url, abouts, measurementMethod, measurementTechnique, variableMeasureds, context) {
+    const s = new LDNode(id, [LDDataset.schemaType], void 0, unwrap(context));
+    s.SetOptionalProperty(LDDataset.identifier, identier, unwrap(context));
+    s.SetOptionalProperty(LDDataset.creator, creators, unwrap(context));
+    s.SetOptionalProperty(LDDataset.dateCreated, dateCreated, unwrap(context));
+    s.SetOptionalProperty(LDDataset.datePublished, datePublished, unwrap(context));
+    s.SetOptionalProperty(LDDataset.dateModified, dateModified, unwrap(context));
+    s.SetOptionalProperty(LDDataset.description, description, unwrap(context));
+    s.SetOptionalProperty(LDDataset.hasPart, hasParts, unwrap(context));
+    s.SetOptionalProperty(LDDataset.name, name, unwrap(context));
+    s.SetOptionalProperty(LDDataset.citation, citations, unwrap(context));
+    s.SetOptionalProperty(LDDataset.comment, comments, unwrap(context));
+    s.SetOptionalProperty(LDDataset.mentions, mentions, unwrap(context));
+    s.SetOptionalProperty(LDDataset.url, url, unwrap(context));
+    s.SetOptionalProperty(LDDataset.about, abouts, unwrap(context));
+    s.SetOptionalProperty(LDDataset.measurementMethod, measurementMethod, unwrap(context));
+    s.SetOptionalProperty(LDDataset.measurementTechnique, measurementTechnique, unwrap(context));
+    s.SetOptionalProperty(LDDataset.variableMeasured, variableMeasureds, unwrap(context));
+    return s;
+  }
+  static createInvestigation(identifier, name, id, creators, dateCreated, datePublished, dateModified, description, hasParts, citations, comments, mentions, url, context) {
+    const id_1 = id == null ? LDDataset.genIDInvesigation() : value(id);
+    const s = LDDataset.create(id_1, identifier, unwrap(creators), unwrap(dateCreated), unwrap(datePublished), unwrap(dateModified), unwrap(description), unwrap(hasParts), name, unwrap(citations), unwrap(comments), unwrap(mentions), unwrap(url), void 0, void 0, void 0, void 0, unwrap(context));
+    s.AdditionalType = ["Investigation"];
+    return s;
+  }
+  static createStudy(identifier, id, creators, dateCreated, datePublished, dateModified, description, hasParts, name, citations, variableMeasureds, comments, url, abouts, context) {
+    const id_1 = id == null ? LDDataset.genIDStudy(identifier) : value(id);
+    const s = LDDataset.create(id_1, identifier, unwrap(creators), unwrap(dateCreated), unwrap(datePublished), unwrap(dateModified), unwrap(description), unwrap(hasParts), unwrap(name), unwrap(citations), unwrap(comments), void 0, unwrap(url), unwrap(abouts), void 0, void 0, unwrap(variableMeasureds), unwrap(context));
+    s.AdditionalType = ["Study"];
+    return s;
+  }
+  static createAssay(identifier, id, name, description, creators, hasParts, measurementMethod, measurementTechnique, variableMeasureds, abouts, comments, context) {
+    const id_1 = id == null ? LDDataset.genIDAssay(identifier) : value(id);
+    const s = LDDataset.create(id_1, identifier, unwrap(creators), void 0, void 0, void 0, unwrap(description), unwrap(hasParts), unwrap(name), void 0, unwrap(comments), void 0, void 0, unwrap(abouts), unwrap(measurementMethod), unwrap(measurementTechnique), unwrap(variableMeasureds), unwrap(context));
+    s.AdditionalType = ["Assay"];
+    return s;
+  }
+}
+
+export { LDDataset };