@nfdi4plants/arctrl 2.3.1 → 2.5.0

package/ROCrate/Generic/Person.js

@@ -0,0 +1,411 @@
+import { bind, some, map, value as value_1, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { LDOrganization } from "./Organization.js";
+import { LDRef, LDNode } from "../LDObject.js";
+import { LDDefinedTerm } from "./DefinedTerm.js";
+import { LDPostalAddress } from "./PostalAddress.js";
+import { ResizeArray_map } from "../../Core/Helper/Collections.js";
+import { clean } from "../Helper.js";
+import { tryGetOrcidURL } from "../../Core/Helper/ORCID.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDPerson {
+    constructor() {
+    }
+    static get schemaType() {
+        return "http://schema.org/Person";
+    }
+    static get givenName() {
+        return "http://schema.org/givenName";
+    }
+    static get affiliation() {
+        return "http://schema.org/affiliation";
+    }
+    static get email() {
+        return "http://schema.org/email";
+    }
+    static get familyName() {
+        return "http://schema.org/familyName";
+    }
+    static get identifier() {
+        return "http://schema.org/identifier";
+    }
+    static get jobTitle() {
+        return "http://schema.org/jobTitle";
+    }
+    static get additionalName() {
+        return "http://schema.org/additionalName";
+    }
+    static get address() {
+        return "http://schema.org/address";
+    }
+    static get disambiguatingDescription() {
+        return "http://schema.org/disambiguatingDescription";
+    }
+    static get faxNumber() {
+        return "http://schema.org/faxNumber";
+    }
+    static get telephone() {
+        return "http://schema.org/telephone";
+    }
+    static tryGetGivenNameAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.givenName, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getGivenNameAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.givenName, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                const n = value_1(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`Property of \`givenName\` of object with @id \`${p.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`givenName\` of object with @id \`${p.Id}\``);
+        }
+    }
+    static setGivenNameAsString(p, n, context) {
+        return p.SetProperty(LDPerson.givenName, n, unwrap(context));
+    }
+    static tryGetAffiliation(p, graph, context) {
+        let n;
+        const matchValue = p.TryGetPropertyAsSingleNode(LDPerson.affiliation, unwrap(graph), unwrap(context));
+        let matchResult, n_1;
+        if (matchValue != null) {
+            if ((n = matchValue, LDOrganization.validate(n, unwrap(context)))) {
+                matchResult = 0;
+                n_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n_1;
+            default:
+                return undefined;
+        }
+    }
+    static setAffiliation(p, a, context) {
+        return p.SetProperty(LDPerson.affiliation, a, unwrap(context));
+    }
+    static tryGetEmailAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.email, unwrap(context));
+        let matchResult, e;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                e = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return e;
+            default:
+                return undefined;
+        }
+    }
+    static setEmailAsString(p, e, context) {
+        return p.SetProperty(LDPerson.email, e, unwrap(context));
+    }
+    static tryGetFamilyNameAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.familyName, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getFamilyNameAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.familyName, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                const n = value_1(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`Property of \`familyName\` of object with @id \`${p.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`familyName\` of object with @id \`${p.Id}\``);
+        }
+    }
+    static setFamilyNameAsString(p, n, context) {
+        return p.SetProperty(LDPerson.familyName, n, unwrap(context));
+    }
+    static tryGetIdentifier(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.identifier, unwrap(context));
+        let matchResult, i;
+        if (matchValue != null) {
+            if (value_1(matchValue) instanceof LDNode) {
+                matchResult = 0;
+                i = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return i;
+            default:
+                return undefined;
+        }
+    }
+    static setIdentifier(p, i, context) {
+        return p.SetProperty(LDPerson.identifier, i, unwrap(context));
+    }
+    static getJobTitlesAsDefinedTerm(p, graph, context) {
+        return p.GetPropertyNodes(LDPerson.jobTitle, (ldObject, context_1) => LDDefinedTerm.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setJobTitleAsDefinedTerm(p, j, context) {
+        return p.SetProperty(LDPerson.jobTitle, j, unwrap(context));
+    }
+    static tryGetAdditionalNameAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.additionalName, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static setAdditionalNameAsString(p, n, context) {
+        return p.SetProperty(LDPerson.additionalName, n, unwrap(context));
+    }
+    static tryGetAddress(p, graph, context) {
+        let r;
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.address, unwrap(context));
+        let matchResult, r_1, a, s;
+        if (matchValue != null) {
+            if (value_1(matchValue) instanceof LDRef) {
+                if ((r = value_1(matchValue), graph != null)) {
+                    matchResult = 0;
+                    r_1 = value_1(matchValue);
+                }
+                else {
+                    matchResult = 3;
+                }
+            }
+            else if (value_1(matchValue) instanceof LDNode) {
+                matchResult = 1;
+                a = value_1(matchValue);
+            }
+            else if (typeof value_1(matchValue) === "string") {
+                matchResult = 2;
+                s = value_1(matchValue);
+            }
+            else {
+                matchResult = 3;
+            }
+        }
+        else {
+            matchResult = 3;
+        }
+        switch (matchResult) {
+            case 0:
+                return map((value) => value, value_1(graph).TryGetNode(r_1.Id));
+            case 1:
+                return some(a);
+            case 2:
+                return some(s);
+            default:
+                return undefined;
+        }
+    }
+    static tryGetAddressAsPostalAddress(p, graph, context) {
+        let n;
+        const matchValue = p.TryGetPropertyAsSingleNode(LDPerson.address, unwrap(graph), unwrap(context));
+        let matchResult, n_1;
+        if (matchValue != null) {
+            if ((n = matchValue, LDPostalAddress.validate(n, unwrap(context)))) {
+                matchResult = 0;
+                n_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n_1;
+            default:
+                return undefined;
+        }
+    }
+    static tryGetAddressAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.address, unwrap(context));
+        let matchResult, a;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                a = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return a;
+            default:
+                return undefined;
+        }
+    }
+    static setAddressAsPostalAddress(p, a, context) {
+        return p.SetProperty(LDPerson.address, a, unwrap(context));
+    }
+    static setAddressAsString(p, a, context) {
+        return p.SetProperty(LDPerson.address, a, unwrap(context));
+    }
+    static getDisambiguatingDescriptionsAsString(p, context) {
+        return ResizeArray_map((v) => v, p.GetPropertyValues(LDPerson.disambiguatingDescription, (value, context_1) => (typeof value === "string"), unwrap(context)));
+    }
+    static setDisambiguatingDescriptionsAsString(p, d, context) {
+        return p.SetProperty(LDPerson.disambiguatingDescription, d, unwrap(context));
+    }
+    static tryGetFaxNumberAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.faxNumber, unwrap(context));
+        let matchResult, f;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                f = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return f;
+            default:
+                return undefined;
+        }
+    }
+    static setFaxNumberAsString(p, f, context) {
+        return p.SetProperty(LDPerson.faxNumber, f, unwrap(context));
+    }
+    static tryGetTelephoneAsString(p, context) {
+        const matchValue = p.TryGetPropertyAsSingleton(LDPerson.telephone, unwrap(context));
+        let matchResult, t;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                t = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return t;
+            default:
+                return undefined;
+        }
+    }
+    static setTelephoneAsString(p, t, context) {
+        return p.SetProperty(LDPerson.telephone, t, unwrap(context));
+    }
+    static genId(givenName, orcid, familyName) {
+        let matchValue;
+        return clean((matchValue = bind(tryGetOrcidURL, orcid), (matchValue == null) ? ((familyName == null) ? (`#Person_${givenName}`) : (`#Person_${givenName}_${value_1(familyName)}`)) : matchValue));
+    }
+    static validate(p, context) {
+        return p.HasType(LDPerson.schemaType, unwrap(context)) && p.HasProperty(LDPerson.givenName, unwrap(context));
+    }
+    static create(givenName, orcid, id, affiliation, email, familyName, identifier, jobTitles, additionalName, address, disambiguatingDescriptions, faxNumber, telephone, context) {
+        const person = new LDNode((id == null) ? LDPerson.genId(givenName, unwrap(orcid), unwrap(familyName)) : id, [LDPerson.schemaType], undefined, unwrap(context));
+        person.SetProperty(LDPerson.givenName, givenName, unwrap(context));
+        person.SetOptionalProperty(LDPerson.affiliation, affiliation, unwrap(context));
+        person.SetOptionalProperty(LDPerson.email, email, unwrap(context));
+        person.SetOptionalProperty(LDPerson.familyName, familyName, unwrap(context));
+        person.SetOptionalProperty(LDPerson.identifier, identifier, unwrap(context));
+        person.SetOptionalProperty(LDPerson.jobTitle, jobTitles, unwrap(context));
+        person.SetOptionalProperty(LDPerson.additionalName, additionalName, unwrap(context));
+        person.SetOptionalProperty(LDPerson.address, address, unwrap(context));
+        person.SetOptionalProperty(LDPerson.disambiguatingDescription, disambiguatingDescriptions, unwrap(context));
+        person.SetOptionalProperty(LDPerson.faxNumber, faxNumber, unwrap(context));
+        person.SetOptionalProperty(LDPerson.telephone, telephone, unwrap(context));
+        return person;
+    }
+}
+
+export function LDPerson_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDPerson", undefined, LDPerson);
+}
+

package/ROCrate/Generic/PostalAddress.js

@@ -0,0 +1,159 @@
+import { value, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { empty, singleton, append, delay, toList } from "../../fable_modules/fable-library-js.4.24.0/Seq.js";
+import { clean } from "../Helper.js";
+import { reduce, isEmpty } from "../../fable_modules/fable-library-js.4.24.0/List.js";
+import { createMissingIdentifier } from "../../Core/Helper/Identifier.js";
+import { printf, toText } from "../../fable_modules/fable-library-js.4.24.0/String.js";
+import { LDNode } from "../LDObject.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDPostalAddress {
+    constructor() {
+    }
+    static get schemaType() {
+        return "http://schema.org/PostalAddress";
+    }
+    static get addressCountry() {
+        return "http://schema.org/addressCountry";
+    }
+    static get postalCode() {
+        return "http://schema.org/postalCode";
+    }
+    static get streetAddress() {
+        return "http://schema.org/streetAddress";
+    }
+    static tryGetAddressCountryAsString(s, context) {
+        const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.addressCountry, 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 getAddressCountryAsString(s, context) {
+        const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.addressCountry, unwrap(context));
+        if (matchValue == null) {
+            throw new Error(`Could not access property \`addressCountry\` of object with @id \`${s.Id}\``);
+        }
+        else if (typeof value(matchValue) === "string") {
+            const n = value(matchValue);
+            return n;
+        }
+        else {
+            throw new Error(`Value of property \`addressCountry\` of object with @id \`${s.Id}\` should have been a string`);
+        }
+    }
+    static setAddressCountryAsString(s, n) {
+        s.SetProperty(LDPostalAddress.addressCountry, n);
+    }
+    static tryGetPostalCodeAsString(s, context) {
+        const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.postalCode, 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 getPostalCodeAsString(s, context) {
+        const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.postalCode, unwrap(context));
+        if (matchValue == null) {
+            throw new Error(`Could not access property \`postalCode\` of object with @id \`${s.Id}\``);
+        }
+        else if (typeof value(matchValue) === "string") {
+            const n = value(matchValue);
+            return n;
+        }
+        else {
+            throw new Error(`Value of property \`postalCode\` of object with @id \`${s.Id}\` should have been a string`);
+        }
+    }
+    static setPostalCodeAsString(s, n) {
+        s.SetProperty(LDPostalAddress.postalCode, n);
+    }
+    static tryGetStreetAddressAsString(s, context) {
+        const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.streetAddress, 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 getStreetAddressAsString(s, context) {
+        const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.streetAddress, unwrap(context));
+        if (matchValue == null) {
+            throw new Error(`Could not access property \`streetAddress\` of object with @id \`${s.Id}\``);
+        }
+        else if (typeof value(matchValue) === "string") {
+            const n = value(matchValue);
+            return n;
+        }
+        else {
+            throw new Error(`Value of property \`streetAddress\` of object with @id \`${s.Id}\` should have been a string`);
+        }
+    }
+    static setStreetAddressAsString(s, n) {
+        s.SetProperty(LDPostalAddress.streetAddress, n);
+    }
+    static genID(addressCountry, postalCode, streetAddress) {
+        let arg;
+        const items = toList(delay(() => append((addressCountry != null) ? singleton("addressCountry") : empty(), delay(() => append((postalCode != null) ? singleton("postalCode") : empty(), delay(() => ((streetAddress != null) ? singleton("streetAddress") : empty())))))));
+        return clean(isEmpty(items) ? createMissingIdentifier() : ((arg = reduce((acc, x) => (`${acc}_${x}`), items), toText(printf("#%s"))(arg))));
+    }
+    static validate(o, context) {
+        return o.HasType(LDPostalAddress.schemaType, unwrap(context));
+    }
+    static create(id, addressCountry, postalCode, streetAddress, context) {
+        const s = new LDNode((id == null) ? LDPostalAddress.genID(unwrap(addressCountry), unwrap(postalCode), unwrap(streetAddress)) : id, [LDPostalAddress.schemaType], undefined, unwrap(context));
+        s.SetOptionalProperty(LDPostalAddress.addressCountry, addressCountry);
+        s.SetOptionalProperty(LDPostalAddress.postalCode, postalCode);
+        s.SetOptionalProperty(LDPostalAddress.streetAddress, streetAddress);
+        return s;
+    }
+}
+
+export function LDPostalAddress_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDPostalAddress", undefined, LDPostalAddress);
+}
+