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

package/dist/ts/ts/Json/PropertyValue.js

@@ -0,0 +1,280 @@
+import { value, unwrap, map } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { OntologyAnnotation } from '../Core/OntologyAnnotation.js';
+import { Value } from '../Core/Value.js';
+import { choose, ofArray } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { tryInclude } from './Encode.js';
+import { context_jsonvalue } from './context/rocrate/property_value_context.js';
+import { map as map$1 } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { object, string } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { AnnotationValue_decoder } from './OntologyAnnotation.js';
+
+function genID(p) {
+  const matchValue = p.GetCategory();
+  const matchValue_1 = p.GetValue();
+  const matchValue_2 = p.GetUnit();
+  let matchResult, t, u, v, t_1, v_1;
+  if (matchValue != null) {
+    if (matchValue_1 != null) {
+      if (matchValue_2 == null) {
+        matchResult = 1;
+        t_1 = value(matchValue);
+        v_1 = value(matchValue_1);
+      } else {
+        matchResult = 0;
+        t = value(matchValue);
+        u = value(matchValue_2);
+        v = value(matchValue_1);
+      }
+    } else {
+      matchResult = 2;
+    }
+  } else {
+    matchResult = 2;
+  }
+  switch (matchResult) {
+    case 0:
+      return `#${p.GetAdditionalType()}/${t.NameText}=${v.Text}${u.NameText}`;
+    case 1:
+      return `#${p.GetAdditionalType()}/${t_1.NameText}=${v_1.Text}`;
+    default:
+      return `#Empty${p.GetAdditionalType()}`;
+  }
+}
+function encoder(pv) {
+  let value_8, value_10;
+  let patternInput;
+  const matchValue = pv.GetCategory();
+  if (matchValue == null) {
+    patternInput = [void 0, void 0];
+  } else {
+    const oa = value(matchValue);
+    patternInput = [oa.Name, oa.TermAccessionNumber];
+  }
+  let patternInput_1;
+  const matchValue_1 = pv.GetValue();
+  if (matchValue_1 == null) {
+    patternInput_1 = [void 0, void 0];
+  } else {
+    const v = value(matchValue_1);
+    switch (v.tag) {
+      case /* Int */
+      1: {
+        const t_1 = v.fields[0] | 0;
+        patternInput_1 = [{
+          Encode(helpers_1) {
+            return helpers_1.encodeSignedIntegralNumber(t_1);
+          }
+        }, void 0];
+        break;
+      }
+      case /* Float */
+      2: {
+        const t_2 = v.fields[0];
+        patternInput_1 = [{
+          Encode(helpers_2) {
+            return helpers_2.encodeDecimalNumber(t_2);
+          }
+        }, void 0];
+        break;
+      }
+      case /* Ontology */
+      0: {
+        const oa_1 = v.fields[0];
+        patternInput_1 = [map((value_3) => ({
+          Encode(helpers_3) {
+            return helpers_3.encodeString(value_3);
+          }
+        }), oa_1.Name), map((value_5) => ({
+          Encode(helpers_4) {
+            return helpers_4.encodeString(value_5);
+          }
+        }), oa_1.TermAccessionNumber)];
+        break;
+      }
+      default: {
+        const t = v.fields[0];
+        patternInput_1 = [{
+          Encode(helpers) {
+            return helpers.encodeString(t);
+          }
+        }, void 0];
+      }
+    }
+  }
+  let patternInput_2;
+  const matchValue_2 = pv.GetUnit();
+  if (matchValue_2 == null) {
+    patternInput_2 = [void 0, void 0];
+  } else {
+    const oa_2 = value(matchValue_2);
+    patternInput_2 = [oa_2.Name, oa_2.TermAccessionNumber];
+  }
+  const values_1 = choose((tupledArg) => map((v_1_1) => [tupledArg[0], v_1_1], tupledArg[1]), ofArray([["@id", (value_8 = genID(pv), {
+    Encode(helpers_5) {
+      return helpers_5.encodeString(value_8);
+    }
+  })], ["@type", {
+    Encode(helpers_6) {
+      return helpers_6.encodeString("PropertyValue");
+    }
+  }], ["additionalType", (value_10 = pv.GetAdditionalType(), {
+    Encode(helpers_7) {
+      return helpers_7.encodeString(value_10);
+    }
+  })], tryInclude("alternateName", (value_11) => ({
+    Encode(helpers_8) {
+      return helpers_8.encodeString(value_11);
+    }
+  }), pv.AlternateName()), tryInclude("measurementMethod", (value_13) => ({
+    Encode(helpers_9) {
+      return helpers_9.encodeString(value_13);
+    }
+  }), pv.MeasurementMethod()), tryInclude("description", (value_15) => ({
+    Encode(helpers_10) {
+      return helpers_10.encodeString(value_15);
+    }
+  }), pv.Description()), tryInclude("category", (value_17) => ({
+    Encode(helpers_11) {
+      return helpers_11.encodeString(value_17);
+    }
+  }), patternInput[0]), tryInclude("categoryCode", (value_19) => ({
+    Encode(helpers_12) {
+      return helpers_12.encodeString(value_19);
+    }
+  }), patternInput[1]), tryInclude("value", (x) => x, patternInput_1[0]), tryInclude("valueCode", (x_1) => x_1, patternInput_1[1]), tryInclude("unit", (value_21) => ({
+    Encode(helpers_13) {
+      return helpers_13.encodeString(value_21);
+    }
+  }), patternInput_2[0]), tryInclude("unitCode", (value_23) => ({
+    Encode(helpers_14) {
+      return helpers_14.encodeString(value_23);
+    }
+  }), patternInput_2[1]), ["@context", context_jsonvalue]]));
+  return {
+    Encode(helpers_15) {
+      const arg = map$1((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_15)], values_1);
+      return helpers_15.encodeObject(arg);
+    }
+  };
+}
+function decoder(create) {
+  return object((get$) => {
+    let value$1, objectArg_7, code_4, objectArg_8;
+    let alternateName;
+    const objectArg = get$.Optional;
+    alternateName = objectArg.Field("alternateName", string);
+    let measurementMethod;
+    const objectArg_1 = get$.Optional;
+    measurementMethod = objectArg_1.Field("measurementMethod", string);
+    let description;
+    const objectArg_2 = get$.Optional;
+    description = objectArg_2.Field("description", string);
+    let category;
+    let name;
+    const objectArg_3 = get$.Optional;
+    name = objectArg_3.Field("category", string);
+    let code;
+    const objectArg_4 = get$.Optional;
+    code = objectArg_4.Field("categoryCode", string);
+    let matchResult, code_1;
+    if (name == null) {
+      if (code != null) {
+        if (value(code) === "") {
+          matchResult = 0;
+        } else {
+          matchResult = 2;
+          code_1 = value(code);
+        }
+      } else {
+        matchResult = 0;
+      }
+    } else if (code != null) {
+      if (value(code) === "") {
+        matchResult = 1;
+      } else {
+        matchResult = 2;
+        code_1 = value(code);
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0: {
+        category = void 0;
+        break;
+      }
+      case 1: {
+        try {
+          category = OntologyAnnotation.create(unwrap(name));
+        } catch (err) {
+          throw new Error(`Error while decoding category (name:${name}): ${err}`);
+        }
+        break;
+      }
+      default:
+        try {
+          category = OntologyAnnotation.fromTermAnnotation(code_1, unwrap(name));
+        } catch (err_1) {
+          throw new Error(`Error while decoding category (name:${name}, code:${code_1}): ${err_1}`);
+        }
+    }
+    let unit;
+    let name_1;
+    const objectArg_5 = get$.Optional;
+    name_1 = objectArg_5.Field("unit", string);
+    let code_2;
+    const objectArg_6 = get$.Optional;
+    code_2 = objectArg_6.Field("unitCode", string);
+    let matchResult_1, code_3;
+    if (name_1 == null) {
+      if (code_2 != null) {
+        if (value(code_2) === "") {
+          matchResult_1 = 0;
+        } else {
+          matchResult_1 = 2;
+          code_3 = value(code_2);
+        }
+      } else {
+        matchResult_1 = 0;
+      }
+    } else if (code_2 != null) {
+      if (value(code_2) === "") {
+        matchResult_1 = 1;
+      } else {
+        matchResult_1 = 2;
+        code_3 = value(code_2);
+      }
+    } else {
+      matchResult_1 = 1;
+    }
+    switch (matchResult_1) {
+      case 0: {
+        unit = void 0;
+        break;
+      }
+      case 1: {
+        try {
+          unit = OntologyAnnotation.create(unwrap(name_1));
+        } catch (err_2) {
+          throw new Error(`Error while decoding unit (name:${name_1}): ${err_2}`);
+        }
+        break;
+      }
+      default:
+        try {
+          unit = OntologyAnnotation.fromTermAnnotation(code_3, unwrap(name_1));
+        } catch (err_3) {
+          throw new Error(`Error while decoding unit (name:${name_1}, code:${code_3}): ${err_3}`);
+        }
+    }
+    return create(alternateName, measurementMethod, description, category, (value$1 = (objectArg_7 = get$.Optional, objectArg_7.Field("value", AnnotationValue_decoder)), code_4 = (objectArg_8 = get$.Optional, objectArg_8.Field("valueCode", string)), value$1 == null && code_4 == null ? void 0 : (() => {
+      try {
+        return Value.fromOptions(value$1, void 0, code_4);
+      } catch (err_4) {
+        throw new Error(`Error while decoding value ${value$1},${code_4}: ${err_4}`);
+      }
+    })()), unit);
+  });
+}
+
+export { decoder, encoder, genID };

package/dist/ts/ts/Json/Publication.d.ts

@@ -1,6 +1,6 @@
 import { FSharpList } from '@fable-org/fable-library-js/List.js';
 import { Option } from '@fable-org/fable-library-js/Option.js';
-import { Decoder$1, IEncodable } from '../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { Decoder$1, IEncodable } from '../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 import { Publication } from '../Core/Publication.js';
 import { IMap } from '@fable-org/fable-library-js/Util.js';
 export declare function encoder(oa: Publication): IEncodable;

package/dist/ts/ts/Json/Publication.js

@@ -0,0 +1,123 @@
+import { ofArray, choose } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { unwrap, map, value } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { tryInclude, tryIncludeSeq } from './Encode.js';
+import { OntologyAnnotation_decoder, OntologyAnnotation_ROCrate_decoderDefinedTerm, OntologyAnnotation_encoder, OntologyAnnotation_ROCrate_encoderDefinedTerm } from './OntologyAnnotation.js';
+import { decoder as decoder$1, ROCrate_decoderDisambiguatingDescription, encoder as encoder$1, ROCrate_encoderDisambiguatingDescription, ISAJson_encoder as ISAJson_encoder$1 } from './Comment.js';
+import { map as map$1 } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { Publication } from '../Core/Publication.js';
+import { object, string, resizeArray } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { Decode_noAdditionalProperties, Decode_uri } from './Decode.js';
+import { replace } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { ROCrate_decodeAuthorListString, ROCrate_encodeAuthorListString } from './Person.js';
+import { context_jsonvalue } from './context/rocrate/isa_publication_context.js';
+
+function encoder(oa) {
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([tryInclude("pubMedID", (value) => ({
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  }), oa.PubMedID), tryInclude("doi", (value_2) => ({
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_2);
+    }
+  }), oa.DOI), tryInclude("authorList", (value_4) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_4);
+    }
+  }), oa.Authors), tryInclude("title", (value_6) => ({
+    Encode(helpers_3) {
+      return helpers_3.encodeString(value_6);
+    }
+  }), oa.Title), tryInclude("status", OntologyAnnotation_encoder, oa.Status), tryIncludeSeq("comments", encoder$1, oa.Comments)]));
+  return {
+    Encode(helpers_4) {
+      const arg = map$1((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_4)], values_1);
+      return helpers_4.encodeObject(arg);
+    }
+  };
+}
+const decoder = object((get$) => {
+  let objectArg, objectArg_1, objectArg_2, objectArg_3, objectArg_4, arg_11, objectArg_5;
+  return new Publication(unwrap((objectArg = get$.Optional, objectArg.Field("pubMedID", Decode_uri))), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("doi", string))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("authorList", string))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("title", string))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("status", OntologyAnnotation_decoder))), unwrap((arg_11 = resizeArray(decoder$1), objectArg_5 = get$.Optional, objectArg_5.Field("comments", arg_11))));
+});
+function ROCrate_genID(p) {
+  const matchValue = p.DOI;
+  if (matchValue == null) {
+    const matchValue_1 = p.PubMedID;
+    if (matchValue_1 == null) {
+      const matchValue_2 = p.Title;
+      if (matchValue_2 == null) {
+        return "#EmptyPublication";
+      } else {
+        return "#Pub_" + replace(value(matchValue_2), " ", "_");
+      }
+    } else {
+      return value(matchValue_1);
+    }
+  } else {
+    return value(matchValue);
+  }
+}
+function ROCrate_encoder(oa) {
+  let value;
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([["@id", (value = ROCrate_genID(oa), {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })], ["@type", {
+    Encode(helpers_1) {
+      return helpers_1.encodeString("Publication");
+    }
+  }], tryInclude("pubMedID", (value_2) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_2);
+    }
+  }), oa.PubMedID), tryInclude("doi", (value_4) => ({
+    Encode(helpers_3) {
+      return helpers_3.encodeString(value_4);
+    }
+  }), oa.DOI), tryInclude("authorList", ROCrate_encodeAuthorListString, oa.Authors), tryInclude("title", (value_6) => ({
+    Encode(helpers_4) {
+      return helpers_4.encodeString(value_6);
+    }
+  }), oa.Title), tryInclude("status", OntologyAnnotation_ROCrate_encoderDefinedTerm, oa.Status), tryIncludeSeq("comments", ROCrate_encoderDisambiguatingDescription, oa.Comments), ["@context", context_jsonvalue]]));
+  return {
+    Encode(helpers_5) {
+      const arg = map$1((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_5)], values_1);
+      return helpers_5.encodeObject(arg);
+    }
+  };
+}
+const ROCrate_decoder = object((get$) => {
+  let objectArg, objectArg_1, objectArg_2, objectArg_3, objectArg_4, arg_11, objectArg_5;
+  return new Publication(unwrap((objectArg = get$.Optional, objectArg.Field("pubMedID", Decode_uri))), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("doi", string))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("authorList", ROCrate_decodeAuthorListString))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("title", string))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("status", OntologyAnnotation_ROCrate_decoderDefinedTerm))), unwrap((arg_11 = resizeArray(ROCrate_decoderDisambiguatingDescription), objectArg_5 = get$.Optional, objectArg_5.Field("comments", arg_11))));
+});
+function ISAJson_encoder(idMap, oa) {
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([tryInclude("pubMedID", (value) => ({
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  }), oa.PubMedID), tryInclude("doi", (value_2) => ({
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_2);
+    }
+  }), oa.DOI), tryInclude("authorList", (value_4) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_4);
+    }
+  }), oa.Authors), tryInclude("title", (value_6) => ({
+    Encode(helpers_3) {
+      return helpers_3.encodeString(value_6);
+    }
+  }), oa.Title), tryInclude("status", OntologyAnnotation_encoder, oa.Status), tryIncludeSeq("comments", (comment) => ISAJson_encoder$1(idMap, comment), oa.Comments)]));
+  return {
+    Encode(helpers_4) {
+      const arg = map$1((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_4)], values_1);
+      return helpers_4.encodeObject(arg);
+    }
+  };
+}
+const ISAJson_allowedFields = ofArray(["pubMedID", "doi", "authorList", "title", "status", "comments"]);
+const ISAJson_decoder = Decode_noAdditionalProperties(ISAJson_allowedFields, decoder);
+
+export { ISAJson_allowedFields, ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_encoder, ROCrate_genID, decoder, encoder };

package/dist/ts/ts/Json/ROCrate/LDContext.d.ts

@@ -1,4 +1,4 @@
-import { IEncodable, Decoder$1 } from '../../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { IEncodable, Decoder$1 } from '../../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 import { LDContext } from '../../ROCrate/LDContext.js';
 export declare const decoder: Decoder$1<LDContext>;
 export declare function encoder(ctx_mut: LDContext): IEncodable;

package/dist/ts/ts/Json/ROCrate/LDContext.js

@@ -0,0 +1,115 @@
+import { ErrorReason$1_BadOneOf, ErrorReason$1_BadPrimitive } from '../../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
+import { LDContext } from '../../ROCrate/LDContext.js';
+import { Getters$2_$ctor_Z4BE6C149, string, Getters$2__get_Errors, resizeArray } from '../../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { isEmpty, length, head } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok } from '../../../node_modules/@fable-org/fable-library-js/Result.js';
+import { initV1_2DRAFT, initV1_1 } from '../../ROCrate/ROCrateContext.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { map, append, toList, delay, singleton, empty } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { seq } from '../../fable_modules/Thoth.Json.Core.0.7.0/Encode.fs.js';
+
+const decoder = {
+  Decode(helpers, value) {
+    let objectArg;
+    const this$ = this;
+    if (helpers.isObject(value)) {
+      const getters = Getters$2_$ctor_Z4BE6C149(helpers, value);
+      const properties = helpers.getProperties(value);
+      let result;
+      const get$ = getters;
+      const o = new LDContext();
+      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.AddMapping(property, (objectArg = get$.Required, objectArg.Field(property, string)));
+          }
+        }
+      } finally {
+        disposeSafe(enumerator);
+      }
+      result = o;
+      const matchValue = Getters$2__get_Errors(getters);
+      if (!isEmpty(matchValue)) {
+        const errors = matchValue;
+        return length(errors) > 1 ? FSharpResult$2_Error(["", ErrorReason$1_BadOneOf(errors)]) : FSharpResult$2_Error(head(matchValue));
+      } else {
+        return FSharpResult$2_Ok(result);
+      }
+    } else if (helpers.isString(value)) {
+      const s = helpers.asString(value);
+      return s === "https://w3id.org/ro/crate/1.2-DRAFT/context" ? FSharpResult$2_Ok(initV1_2DRAFT()) : s === "https://w3id.org/ro/crate/1.1/context" ? FSharpResult$2_Ok(initV1_1()) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value)]);
+    } else if (helpers.isArray(value)) {
+      const matchValue_1 = resizeArray(this$).Decode(helpers, value);
+      return matchValue_1.tag === /* Error */
+      1 ? FSharpResult$2_Error(matchValue_1.fields[0]) : FSharpResult$2_Ok(new LDContext(void 0, matchValue_1.fields[0]));
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value)]);
+    }
+  }
+};
+function encoder(ctx_mut) {
+  let source_4;
+  encoder:
+    while (true) {
+      const ctx = ctx_mut;
+      const matchValue = ctx.Name;
+      let matchResult;
+      if (matchValue != null) {
+        switch (value(matchValue)) {
+          case "https://w3id.org/ro/crate/1.2-DRAFT/context": {
+            matchResult = 0;
+            break;
+          }
+          case "https://w3id.org/ro/crate/1.1/context": {
+            matchResult = 1;
+            break;
+          }
+          default:
+            matchResult = 2;
+        }
+      } else {
+        matchResult = 2;
+      }
+      switch (matchResult) {
+        case 0:
+          return {
+            Encode(helpers) {
+              return helpers.encodeString("https://w3id.org/ro/crate/1.2-DRAFT/context");
+            }
+          };
+        case 1:
+          return {
+            Encode(helpers_1) {
+              return helpers_1.encodeString("https://w3id.org/ro/crate/1.1/context");
+            }
+          };
+        default: {
+          let mappings;
+          const values = map((kv) => [kv[0], {
+            Encode(helpers_2) {
+              return helpers_2.encodeString(kv[1]);
+            }
+          }], ctx.Mappings);
+          mappings = {
+            Encode(helpers_3) {
+              const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_3)], values);
+              return helpers_3.encodeObject(arg);
+            }
+          };
+          if (ctx.BaseContexts.length === 0) {
+            return mappings;
+          } else if (ctx.BaseContexts.length === 1 && ctx.Mappings.size === 0) {
+            ctx_mut = ctx.BaseContexts[0];
+            continue encoder;
+          } else {
+            return seq((source_4 = map(encoder, ctx.BaseContexts), append(toList(delay(() => ctx.Mappings.size !== 0 ? singleton(mappings) : empty())), source_4)));
+          }
+        }
+      }
+    }
+}
+
+export { decoder, encoder };

package/dist/ts/ts/Json/ROCrate/LDGraph.d.ts

@@ -1,4 +1,4 @@
-import { Decoder$1, IEncodable } from '../../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { Decoder$1, IEncodable } from '../../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 import { LDGraph } from '../../ROCrate/LDObject.js';
 export declare function encoder(obj: LDGraph): IEncodable;
 export declare const decoder: Decoder$1<LDGraph>;

package/dist/ts/ts/Json/ROCrate/LDGraph.js

@@ -0,0 +1,83 @@
+import { choose, isEmpty, length, head } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { map, unwrap } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { ErrorReason$1_BadOneOf, ErrorReason$1_BadPrimitive } from '../../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
+import { toList, delay, map as map$1, append, singleton, collect, empty } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { tryInclude } from '../Encode.js';
+import { decoder as decoder$1, encoder as encoder$1 } from './LDContext.js';
+import { genericDecoder, decoder as decoder$2, genericEncoder, encoder as encoder$2 } from './LDNode.js';
+import { seq } from '../../fable_modules/Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { LDGraph } from '../../ROCrate/LDObject.js';
+import { Getters$2_$ctor_Z4BE6C149, string, resizeArray, Getters$2__get_Errors } from '../../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok } from '../../../node_modules/@fable-org/fable-library-js/Result.js';
+
+function encoder(obj) {
+  const values_2 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), toList(delay(() => append(singleton(tryInclude("@id", (value) => ({
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  }), obj.Id)), delay(() => append(singleton(tryInclude("@context", encoder$1, obj.TryGetContext())), delay(() => append(collect((kv) => {
+    const l = kv[0].toLocaleLowerCase();
+    return l !== "id" && l !== "@context" && l !== "nodes" && l !== "mappings" ? singleton([kv[0], genericEncoder(kv[1])]) : empty();
+  }, obj.GetProperties(true)), delay(() => singleton(["@graph", seq(map$1(encoder$2, obj.Nodes))]))))))))));
+  return {
+    Encode(helpers_1) {
+      const arg = map$1((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_1)], values_2);
+      return helpers_1.encodeObject(arg);
+    }
+  };
+}
+const decoder = {
+  Decode(helpers, value) {
+    let objectArg_3;
+    if (helpers.isObject(value)) {
+      const getters = Getters$2_$ctor_Z4BE6C149(helpers, value);
+      const properties = helpers.getProperties(value);
+      let result;
+      const get$ = getters;
+      let id;
+      const objectArg = get$.Optional;
+      id = objectArg.Field("@id", string);
+      let context;
+      const objectArg_1 = get$.Optional;
+      context = objectArg_1.Field("@context", decoder$1);
+      let nodes;
+      const arg_5 = resizeArray(decoder$2);
+      const objectArg_2 = get$.Required;
+      nodes = objectArg_2.Field("@graph", arg_5);
+      const o = new LDGraph(unwrap(id), void 0, unwrap(context));
+      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 !== "@graph" && property !== "@context") {
+            o.SetProperty(property, (objectArg_3 = get$.Required, objectArg_3.Field(property, genericDecoder)));
+          }
+        }
+      } finally {
+        disposeSafe(enumerator);
+      }
+      let enumerator_1 = getEnumerator(nodes);
+      try {
+        while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+          const node = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+          o.AddNode(node);
+        }
+      } finally {
+        disposeSafe(enumerator_1);
+      }
+      result = o;
+      const matchValue = Getters$2__get_Errors(getters);
+      if (!isEmpty(matchValue)) {
+        const errors = matchValue;
+        return length(errors) > 1 ? FSharpResult$2_Error(["", ErrorReason$1_BadOneOf(errors)]) : FSharpResult$2_Error(head(matchValue));
+      } else {
+        return FSharpResult$2_Ok(result);
+      }
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value)]);
+    }
+  }
+};
+
+export { decoder, encoder };

package/dist/ts/ts/Json/ROCrate/LDNode.d.ts

@@ -1,4 +1,4 @@
-import { Decoder$1, IEncodable } from '../../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { Decoder$1, IEncodable } from '../../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 import { LDNode } from '../../ROCrate/LDObject.js';
 export declare function genericEncoder(obj: any): IEncodable;
 export declare function encoder(obj: LDNode): IEncodable;