@nfdi4plants/arctrl 2.4.0 → 2.5.0

package/Json/{LDObject.js → ROCrate/LDNode.js}

@@ -1,15 +1,18 @@
-import { dateTime } from "./Encode.js";
-import { LDObject } from "../ROCrate/LDObject.js";
-import { int32ToString, disposeSafe, getEnumerator, isIterable, defaultOf, equals } from "../fable_modules/fable-library-js.4.24.0/Util.js";
-import { list } from "../fable_modules/Thoth.Json.Core.0.4.0/Encode.fs.js";
-import { empty, singleton, append, choose, enumerateFromFunctions, map, delay, toList } from "../fable_modules/fable-library-js.4.24.0/Seq.js";
-import { value as value_10 } from "../fable_modules/fable-library-js.4.24.0/Option.js";
-import { decimal, int, oneOf, map as map_1, Getters$2__get_Errors, string, Getters$2_$ctor_Z4BE6C149 } from "../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js";
-import { ofArray, head, length, isEmpty } from "../fable_modules/fable-library-js.4.24.0/List.js";
-import { ErrorReason$1 } from "../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js";
-import { FSharpResult$2 } from "../fable_modules/fable-library-js.4.24.0/Result.js";
-import { fold } from "../fable_modules/fable-library-js.4.24.0/Array.js";
-import { Helpers_prependPath } from "./Decode.js";
+import { resizeArrayOrSingleton, dateTime } from "../Encode.js";
+import { LDNode, LDRef, LDValue } from "../../ROCrate/LDObject.js";
+import { decoder as decoder_2, encoder as encoder_1 } from "./LDValue.js";
+import { decoder as decoder_3, encoder as encoder_2 } from "./LDRef.js";
+import { int32ToString, disposeSafe, getEnumerator, isIterable, defaultOf, equals } from "../../fable_modules/fable-library-js.4.24.0/Util.js";
+import { list } from "../../fable_modules/Thoth.Json.Core.0.4.0/Encode.fs.js";
+import { collect, empty, singleton, append, enumerateFromFunctions, map, delay, toList } from "../../fable_modules/fable-library-js.4.24.0/Seq.js";
+import { decoder as decoder_1, encoder as encoder_3 } from "./LDContext.js";
+import { decimal, int, oneOf, map as map_1, Getters$2__get_Errors, string, Getters$2_$ctor_Z4BE6C149 } from "../../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js";
+import { Helpers_prependPath, Decode_resizeArrayOrSingleton } from "../Decode.js";
+import { value as value_12, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { ofArray, head, length, isEmpty } from "../../fable_modules/fable-library-js.4.24.0/List.js";
+import { ErrorReason$1 } from "../../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js";
+import { FSharpResult$2 } from "../../fable_modules/fable-library-js.4.24.0/Result.js";
+import { fold } from "../../fable_modules/fable-library-js.4.24.0/Array.js";
 
 export function genericEncoder(obj) {
     if (typeof obj === "string") {
@@ -43,7 +46,13 @@ export function genericEncoder(obj) {
     else if (obj instanceof Date) {
         return dateTime(obj);
     }
-    else if (obj instanceof LDObject) {
+    else if (obj instanceof LDValue) {
+        return encoder_1(obj);
+    }
+    else if (obj instanceof LDRef) {
+        return encoder_2(obj);
+    }
+    else if (obj instanceof LDNode) {
         return encoder(obj);
     }
     else if (equals(obj, defaultOf())) {
@@ -63,38 +72,28 @@ export function genericEncoder(obj) {
 }
 
 export function encoder(obj) {
-    let values;
-    const source_2 = choose((kv) => {
-        const l = kv[0].toLocaleLowerCase();
-        if (((l !== "id") && (l !== "schematype")) && (l !== "additionaltype")) {
-            return [kv[0], genericEncoder(kv[1])];
-        }
-        else {
-            return undefined;
-        }
-    }, obj.GetProperties(true));
-    values = append(toList(delay(() => {
+    const values = toList(delay(() => {
         let value;
         return append(singleton(["@id", (value = obj.Id, {
             Encode(helpers) {
                 return helpers.encodeString(value);
             },
-        })]), delay(() => {
-            let value_1;
-            return append(singleton(["@type", (value_1 = obj.SchemaType, {
-                Encode(helpers_1) {
-                    return helpers_1.encodeString(value_1);
-                },
-            })]), delay(() => {
-                let value_2;
-                return (obj.AdditionalType != null) ? singleton(["additionalType", (value_2 = value_10(obj.AdditionalType), {
-                    Encode(helpers_2) {
-                        return helpers_2.encodeString(value_2);
-                    },
-                })]) : empty();
-            }));
-        }));
-    })), source_2);
+        })]), delay(() => append(singleton(["@type", resizeArrayOrSingleton((value_1) => ({
+            Encode(helpers_1) {
+                return helpers_1.encodeString(value_1);
+            },
+        }), obj.SchemaType)]), delay(() => append((obj.AdditionalType.length !== 0) ? singleton(["additionalType", resizeArrayOrSingleton((value_3) => ({
+            Encode(helpers_2) {
+                return helpers_2.encodeString(value_3);
+            },
+        }), obj.AdditionalType)]) : empty(), delay(() => {
+            let matchValue;
+            return append((matchValue = obj.TryGetContext(), (matchValue != null) ? singleton(["@context", encoder_3(matchValue)]) : (empty())), delay(() => collect((kv) => {
+                const l = kv[0].toLocaleLowerCase();
+                return ((((((l !== "id") && (l !== "schematype")) && (l !== "additionaltype")) && (l !== "@context")) && !l.startsWith("init@")) && !l.startsWith("init_")) ? singleton([kv[0], genericEncoder(kv[1])]) : empty();
+            }, obj.GetProperties(true))));
+        }))))));
+    }));
     return {
         Encode(helpers_3) {
             const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_3)], values);
@@ -112,28 +111,38 @@ export function getDecoder(expectObject) {
     const decode = (expectObject_1) => {
         const decodeObject = {
             Decode(helpers, value) {
-                let objectArg_1, arg_5, objectArg_2;
+                let arg_7, objectArg_3, arg_9, objectArg_4;
                 if (helpers.isObject(value)) {
                     const getters = Getters$2_$ctor_Z4BE6C149(helpers, value);
                     const properties = helpers.getProperties(value);
                     let result;
                     const get$ = getters;
                     let t;
+                    const arg_1 = Decode_resizeArrayOrSingleton(string);
                     const objectArg = get$.Required;
-                    t = objectArg.Field("@type", string);
-                    const o = new LDObject((objectArg_1 = get$.Required, objectArg_1.Field("@id", string)), t);
+                    t = objectArg.Field("@type", arg_1);
+                    let id;
+                    const objectArg_1 = get$.Required;
+                    id = objectArg_1.Field("@id", string);
+                    let context;
+                    const objectArg_2 = get$.Optional;
+                    context = objectArg_2.Field("@context", decoder_1);
+                    const o = new LDNode(id, t, unwrap((arg_7 = Decode_resizeArrayOrSingleton(string), (objectArg_3 = get$.Optional, objectArg_3.Field("additionalType", arg_7)))));
                     const enumerator = getEnumerator(properties);
                     try {
                         while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
                             const property = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-                            if ((property !== "@id") && (property !== "@type")) {
-                                o.SetProperty(property, (arg_5 = decode(false), (objectArg_2 = get$.Required, objectArg_2.Field(property, arg_5))));
+                            if (((property !== "@id") && (property !== "@type")) && (property !== "@context")) {
+                                o.SetProperty(property, (arg_9 = decode(false), (objectArg_4 = get$.Required, objectArg_4.Field(property, arg_9))));
                             }
                         }
                     }
                     finally {
                         disposeSafe(enumerator);
                     }
+                    if (context != null) {
+                        o.SetContext(value_12(context));
+                    }
                     result = o;
                     const matchValue = Getters$2__get_Errors(getters);
                     if (!isEmpty(matchValue)) {
@@ -183,7 +192,7 @@ export function getDecoder(expectObject) {
             return map_1((value_4) => value_4, decodeObject);
         }
         else {
-            return oneOf(ofArray([map_1((value_5) => value_5, decodeObject), map_1((value_6) => value_6, resizeArray), map_1((value_7) => value_7, string), map_1((value_8) => value_8, int), map_1((value_9) => value_9, decimal)]));
+            return oneOf(ofArray([map_1((value_5) => value_5, decoder_2), map_1((value_6) => value_6, decodeObject), map_1((value_7) => value_7, decoder_3), map_1((value_8) => value_8, resizeArray), map_1((value_9) => value_9, string), map_1((value_10) => value_10, int), map_1((value_11) => value_11, decimal)]));
         }
     };
     return decode(expectObject);

package/Json/ROCrate/LDRef.js

@@ -0,0 +1,25 @@
+import { string, object } from "../../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js";
+import { LDRef } from "../../ROCrate/LDObject.js";
+import { singleton } from "../../fable_modules/fable-library-js.4.24.0/List.js";
+import { map } from "../../fable_modules/fable-library-js.4.24.0/Seq.js";
+
+export const decoder = object((decoders) => {
+    let objectArg;
+    return new LDRef((objectArg = decoders.Required, objectArg.Field("@id", string)));
+});
+
+export function encoder(r) {
+    let value;
+    const values = singleton(["@id", (value = r.Id, {
+        Encode(helpers) {
+            return helpers.encodeString(value);
+        },
+    })]);
+    return {
+        Encode(helpers_1) {
+            const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+            return helpers_1.encodeObject(arg);
+        },
+    };
+}
+

package/Json/ROCrate/LDValue.js

@@ -0,0 +1,66 @@
+import { object, decimal, int, string, map, oneOf } from "../../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js";
+import { ofArray } from "../../fable_modules/fable-library-js.4.24.0/List.js";
+import { dateTime } from "../Encode.js";
+import { LDValue } from "../../ROCrate/LDObject.js";
+import { unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { map as map_1 } from "../../fable_modules/fable-library-js.4.24.0/Seq.js";
+
+export const genericDecoder = oneOf(ofArray([map((value) => value, string), map((value_1) => value_1, int), map((value_2) => value_2, decimal)]));
+
+export function genericEncoder(value) {
+    if (typeof value === "string") {
+        return {
+            Encode(helpers) {
+                return helpers.encodeString(value);
+            },
+        };
+    }
+    else if (typeof value === "number") {
+        return {
+            Encode(helpers_1) {
+                return helpers_1.encodeSignedIntegralNumber(value);
+            },
+        };
+    }
+    else if (typeof value === "boolean") {
+        return {
+            Encode(helpers_2) {
+                return helpers_2.encodeBool(value);
+            },
+        };
+    }
+    else if (typeof value === "number") {
+        return {
+            Encode(helpers_3) {
+                return helpers_3.encodeDecimalNumber(value);
+            },
+        };
+    }
+    else if (value instanceof Date) {
+        return dateTime(value);
+    }
+    else {
+        throw new Error("Unknown type");
+    }
+}
+
+export const decoder = object((decoders) => {
+    let objectArg, objectArg_1;
+    return new LDValue((objectArg = decoders.Required, objectArg.Field("@value", genericDecoder)), unwrap((objectArg_1 = decoders.Optional, objectArg_1.Field("@type", string))));
+});
+
+export function encoder(v) {
+    let value;
+    const values = ofArray([["@value", genericEncoder(v.Value)], ["@type", (value = v.ValueType, {
+        Encode(helpers) {
+            return helpers.encodeString(value);
+        },
+    })]]);
+    return {
+        Encode(helpers_1) {
+            const arg = map_1((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_1)], values);
+            return helpers_1.encodeObject(arg);
+        },
+    };
+}
+

package/JsonIO/LDObject.js

@@ -1,11 +1,12 @@
 import { fromString } from "../fable_modules/Thoth.Json.JavaScript.0.3.0/Decode.fs.js";
-import { encoder, decoder as decoder_1 } from "../Json/LDObject.js";
+import { encoder, decoder as decoder_1 } from "../Json/ROCrate/LDNode.js";
 import { printf, toText } from "../fable_modules/fable-library-js.4.24.0/String.js";
 import { toString } from "../fable_modules/Thoth.Json.JavaScript.0.3.0/Encode.fs.js";
 import { defaultSpaces } from "../Json/Encode.js";
 import { unwrap } from "../fable_modules/fable-library-js.4.24.0/Option.js";
+import { encoder as encoder_1, decoder as decoder_2 } from "../Json/ROCrate/LDGraph.js";
 
-export function ARCtrl_ROCrate_LDObject__LDObject_fromROCrateJsonString_Static_Z721C83C5(s) {
+export function ARCtrl_ROCrate_LDNode__LDNode_fromROCrateJsonString_Static_Z721C83C5(s) {
     const matchValue = fromString(decoder_1, s);
     if (matchValue.tag === 1) {
         throw new Error(toText(printf("Error decoding string: %O"))(matchValue.fields[0]));
@@ -18,14 +19,38 @@ export function ARCtrl_ROCrate_LDObject__LDObject_fromROCrateJsonString_Static_Z
 /**
  * exports in json-ld format
  */
-export function ARCtrl_ROCrate_LDObject__LDObject_toROCrateJsonString_Static_71136F3F(spaces) {
+export function ARCtrl_ROCrate_LDNode__LDNode_toROCrateJsonString_Static_71136F3F(spaces) {
     return (obj) => {
         const value = encoder(obj);
         return toString(defaultSpaces(spaces), value);
     };
 }
 
-export function ARCtrl_ROCrate_LDObject__LDObject_ToROCrateJsonString_71136F3F(this$, spaces) {
-    return ARCtrl_ROCrate_LDObject__LDObject_toROCrateJsonString_Static_71136F3F(unwrap(spaces))(this$);
+export function ARCtrl_ROCrate_LDNode__LDNode_ToROCrateJsonString_71136F3F(this$, spaces) {
+    return ARCtrl_ROCrate_LDNode__LDNode_toROCrateJsonString_Static_71136F3F(unwrap(spaces))(this$);
+}
+
+export function ARCtrl_ROCrate_LDGraph__LDGraph_fromROCrateJsonString_Static_Z721C83C5(s) {
+    const matchValue = fromString(decoder_2, s);
+    if (matchValue.tag === 1) {
+        throw new Error(toText(printf("Error decoding string: %O"))(matchValue.fields[0]));
+    }
+    else {
+        return matchValue.fields[0];
+    }
+}
+
+/**
+ * exports in json-ld format
+ */
+export function ARCtrl_ROCrate_LDGraph__LDGraph_toROCrateJsonString_Static_71136F3F(spaces) {
+    return (obj) => {
+        const value = encoder_1(obj);
+        return toString(defaultSpaces(spaces), value);
+    };
+}
+
+export function ARCtrl_ROCrate_LDGraph__LDGraph_ToROCrateJsonString_71136F3F(this$, spaces) {
+    return ARCtrl_ROCrate_LDGraph__LDGraph_toROCrateJsonString_Static_71136F3F(unwrap(spaces))(this$);
 }
 

package/ROCrate/ArcROCrateMetadata.js

@@ -1,13 +1,14 @@
 import { defaultOf } from "../fable_modules/fable-library-js.4.24.0/Util.js";
 import { FSharpRef } from "../fable_modules/fable-library-js.4.24.0/Types.js";
-import { setOptionalProperty } from "../fable_modules/DynamicObj.4.0.3/DynObj.fs.js";
-import { DynamicObj } from "../fable_modules/DynamicObj.4.0.3/DynamicObj.fs.js";
-import { LDObject_$reflection, LDObject, LDContext_$ctor } from "./LDObject.js";
+import { setOptionalProperty } from "../fable_modules/DynamicObj.7.0.1/DynObj.fs.js";
+import { DynamicObj } from "../fable_modules/DynamicObj.7.0.1/DynamicObj.fs.js";
+import { LDContext } from "./LDContext.js";
+import { LDNode_$reflection, LDNode } from "./LDObject.js";
 import { class_type } from "../fable_modules/fable-library-js.4.24.0/Reflection.js";
 
-export class ArcROCrateMetadata extends LDObject {
+export class ArcROCrateMetadata extends LDNode {
     constructor(about) {
-        super("ro-crate-metadata", "CreativeWork");
+        super("ro-crate-metadata", ["CreativeWork"]);
         const this$ = new FSharpRef(defaultOf());
         this$.contents = this;
         this["init@5"] = 1;
@@ -15,21 +16,21 @@ export class ArcROCrateMetadata extends LDObject {
         const conformsTo = new DynamicObj();
         conformsTo.SetProperty("@id", "https://w3id.org/ro/crate/1.1");
         this$.contents.SetProperty("conformsTo", conformsTo);
-        const context = LDContext_$ctor();
-        context.SetProperty("sdo", "http://schema.org/");
-        context.SetProperty("arc", "http://purl.org/nfdi4plants/ontology/");
-        context.SetProperty("CreativeWork", "sdo:CreativeWork");
-        context.SetProperty("about", "sdo:about");
-        context.SetProperty("conformsTo", "sdo:conformsTo");
+        const context = new LDContext();
+        context.AddMapping("sdo", "http://schema.org/");
+        context.AddMapping("arc", "http://purl.org/nfdi4plants/ontology/");
+        context.AddMapping("CreativeWork", "sdo:CreativeWork");
+        context.AddMapping("about", "sdo:about");
+        context.AddMapping("conformsTo", "sdo:conformsTo");
         this$.contents.SetProperty("@context", context);
     }
 }
 
 export function ArcROCrateMetadata_$reflection() {
-    return class_type("ARCtrl.ROCrate.ArcROCrateMetadata", undefined, ArcROCrateMetadata, LDObject_$reflection());
+    return class_type("ARCtrl.ROCrate.ArcROCrateMetadata", undefined, ArcROCrateMetadata, LDNode_$reflection());
 }
 
-export function ArcROCrateMetadata_$ctor_Z475E1643(about) {
+export function ArcROCrateMetadata_$ctor_Z7020538(about) {
     return new ArcROCrateMetadata(about);
 }
 

package/ROCrate/Generic/Comment.js

@@ -0,0 +1,115 @@
+import { value, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { clean } from "../Helper.js";
+import { LDNode } from "../LDObject.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDComment {
+    constructor() {
+    }
+    static get schemaType() {
+        return "http://schema.org/Comment";
+    }
+    static get text() {
+        return "http://schema.org/text";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static tryGetTextAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDComment.text, 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 getTextAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDComment.text, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                const tc = value(matchValue);
+                return tc;
+            }
+            else {
+                throw new Error(`Property of \`text\` of object with @id \`${dt.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`text\` of object with @id \`${dt.Id}\``);
+        }
+    }
+    static setTextAsString(dt, text, context) {
+        return dt.SetProperty(LDComment.text, text, unwrap(context));
+    }
+    static tryGetNameAsString(dt, context) {
+        const matchValue = dt.TryGetPropertyAsSingleton(LDComment.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(LDComment.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(LDComment.name, name, unwrap(context));
+    }
+    static genID(name, text) {
+        return clean((text == null) ? (`#LDComment_${name}`) : (`#LDComment_${name}_${text}`));
+    }
+    static validate(dt, context) {
+        return dt.HasType(LDComment.schemaType, unwrap(context)) && dt.HasProperty(LDComment.name, unwrap(context));
+    }
+    static create(name, id, text, context) {
+        const dt = new LDNode((id == null) ? LDComment.genID(name, unwrap(text)) : id, [LDComment.schemaType], undefined, unwrap(context));
+        dt.SetProperty(LDComment.name, name, unwrap(context));
+        dt.SetOptionalProperty(LDComment.text, text, unwrap(context));
+        return dt;
+    }
+}
+
+export function LDComment_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDComment", undefined, LDComment);
+}
+