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

package/dist/ts/ts/Json/Comment.js

@@ -0,0 +1,112 @@
+import { choose, ofArray } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { unwrap, map as map$1, value } from '../../node_modules/@fable-org/fable-library-js/Option.js';
+import { tryInclude } from './Encode.js';
+import { map as map$2 } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { Comment$ } from '../Core/Comment.js';
+import { object, string, map } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { replace } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { context_jsonvalue } from './context/rocrate/isa_comment_context.js';
+import { toString } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { encode } from './IDTable.js';
+
+function encoder(comment) {
+  const values_1 = choose((tupledArg) => map$1((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([tryInclude("name", (value) => ({
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  }), comment.Name), tryInclude("value", (value_2) => ({
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_2);
+    }
+  }), comment.Value)]));
+  return {
+    Encode(helpers_2) {
+      const arg = map$2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_2)], values_1);
+      return helpers_2.encodeObject(arg);
+    }
+  };
+}
+const decoder = object((get$) => {
+  let objectArg, objectArg_1;
+  return new Comment$(unwrap((objectArg = get$.Optional, objectArg.Field("name", string))), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("value", string))));
+});
+function ROCrate_genID(c) {
+  const matchValue = c.Name;
+  if (matchValue == null) {
+    return "#EmptyComment";
+  } else {
+    const n = value(matchValue);
+    const v = c.Value != null ? "_" + replace(value(c.Value), " ", "_") : "";
+    return "#Comment_" + replace(n, " ", "_") + v;
+  }
+}
+function ROCrate_encoder(comment) {
+  let value;
+  const values_1 = choose((tupledArg) => map$1((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([["@id", (value = ROCrate_genID(comment), {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  })], ["@type", {
+    Encode(helpers_1) {
+      return helpers_1.encodeString("Comment");
+    }
+  }], tryInclude("name", (value_2) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_2);
+    }
+  }), comment.Name), tryInclude("value", (value_4) => ({
+    Encode(helpers_3) {
+      return helpers_3.encodeString(value_4);
+    }
+  }), comment.Value), ["@context", context_jsonvalue]]));
+  return {
+    Encode(helpers_4) {
+      const arg = map$2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_4)], values_1);
+      return helpers_4.encodeObject(arg);
+    }
+  };
+}
+const ROCrate_decoder = object((get$) => {
+  let objectArg, objectArg_1;
+  return new Comment$(unwrap((objectArg = get$.Optional, objectArg.Field("name", string))), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("value", string))));
+});
+function ROCrate_encoderDisambiguatingDescription(comment) {
+  const value = toString(comment);
+  return {
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  };
+}
+const ROCrate_decoderDisambiguatingDescription = map((s) => Comment$.fromString(s), string);
+function ISAJson_encoder(idMap, comment) {
+  const f = (comment_1) => {
+    const values_1 = choose((tupledArg) => map$1((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([tryInclude("@id", (value) => ({
+      Encode(helpers) {
+        return helpers.encodeString(value);
+      }
+    }), ROCrate_genID(comment_1)), tryInclude("name", (value_2) => ({
+      Encode(helpers_1) {
+        return helpers_1.encodeString(value_2);
+      }
+    }), comment_1.Name), tryInclude("value", (value_4) => ({
+      Encode(helpers_2) {
+        return helpers_2.encodeString(value_4);
+      }
+    }), comment_1.Value)]));
+    return {
+      Encode(helpers_3) {
+        const arg = map$2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_3)], values_1);
+        return helpers_3.encodeObject(arg);
+      }
+    };
+  };
+  if (idMap == null) {
+    return f(comment);
+  } else {
+    return encode(ROCrate_genID, f, comment, value(idMap));
+  }
+}
+const ISAJson_decoder = decoder;
+
+export { ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_decoderDisambiguatingDescription, ROCrate_encoder, ROCrate_encoderDisambiguatingDescription, ROCrate_genID, decoder, encoder };

package/dist/ts/ts/Json/Data.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 { Data } from '../Core/Data.js';
 import { IMap } from '@fable-org/fable-library-js/Util.js';
 import { int32 } from '@fable-org/fable-library-js/Int32.js';

package/dist/ts/ts/Json/Data.js

@@ -0,0 +1,138 @@
+import { ofArray, choose, singleton } 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 { ROCrate_decoder as ROCrate_decoder$1, ISAJson_decoder as ISAJson_decoder$1, ROCrate_encoder as ROCrate_encoder$1, ISAJson_encoder as ISAJson_encoder$1 } from './DataFile.js';
+import { ROCrate_decoder as ROCrate_decoder$2, ISAJson_decoder as ISAJson_decoder$2, ROCrate_encoder as ROCrate_encoder$2, decoder as decoder$1, encoder as encoder$1, ISAJson_encoder as ISAJson_encoder$2 } from './Comment.js';
+import { map as map$1 } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { Data } from '../Core/Data.js';
+import { object, string, resizeArray } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { Decode_objectNoAdditionalProperties, Decode_uri } from './Decode.js';
+import { decodeString, encodeString } from './StringTable.js';
+import { replace } from '../../node_modules/@fable-org/fable-library-js/String.js';
+import { URIModule_toString } from '../Core/URI.js';
+import { list } from '../fable_modules/Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { context_jsonvalue } from './context/rocrate/isa_data_context.js';
+import { encode } from './IDTable.js';
+
+function encoder(d) {
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([tryInclude("@id", (value) => ({
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  }), d.ID), tryInclude("name", (value_2) => ({
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_2);
+    }
+  }), d.Name), tryInclude("dataType", ISAJson_encoder$1, d.DataType), tryInclude("format", (value_4) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_4);
+    }
+  }), d.Format), tryInclude("selectorFormat", (value_6) => ({
+    Encode(helpers_3) {
+      return helpers_3.encodeString(value_6);
+    }
+  }), d.SelectorFormat), tryIncludeSeq("comments", encoder$1, d.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 Data(unwrap((objectArg = get$.Optional, objectArg.Field("@id", Decode_uri))), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("name", string))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("dataType", ISAJson_decoder$1))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("format", string))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("selectorFormat", Decode_uri))), unwrap((arg_11 = resizeArray(decoder$1), objectArg_5 = get$.Optional, objectArg_5.Field("comments", arg_11))));
+});
+function compressedEncoder(stringTable, d) {
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([tryInclude("i", (s) => encodeString(stringTable, s), d.ID), tryInclude("n", (s_1) => encodeString(stringTable, s_1), d.Name), tryInclude("d", ISAJson_encoder$1, d.DataType), tryInclude("f", (s_2) => encodeString(stringTable, s_2), d.Format), tryInclude("s", (s_3) => encodeString(stringTable, s_3), d.SelectorFormat), tryIncludeSeq("c", encoder$1, d.Comments)]));
+  return {
+    Encode(helpers) {
+      const arg = map$1((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers)], values_1);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+function compressedDecoder(stringTable) {
+  return object((get$) => {
+    let arg_1, objectArg, arg_3, objectArg_1, objectArg_2, arg_7, objectArg_3, arg_9, objectArg_4, arg_11, objectArg_5;
+    return new Data(unwrap((arg_1 = decodeString(stringTable), objectArg = get$.Optional, objectArg.Field("i", arg_1))), unwrap((arg_3 = decodeString(stringTable), objectArg_1 = get$.Optional, objectArg_1.Field("n", arg_3))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("d", ISAJson_decoder$1))), unwrap((arg_7 = decodeString(stringTable), objectArg_3 = get$.Optional, objectArg_3.Field("f", arg_7))), unwrap((arg_9 = decodeString(stringTable), objectArg_4 = get$.Optional, objectArg_4.Field("s", arg_9))), unwrap((arg_11 = resizeArray(decoder$1), objectArg_5 = get$.Optional, objectArg_5.Field("c", arg_11))));
+  });
+}
+function ROCrate_genID(d) {
+  const matchValue = d.ID;
+  if (matchValue == null) {
+    const matchValue_1 = d.Name;
+    if (matchValue_1 == null) {
+      return "#EmptyData";
+    } else {
+      return replace(value(matchValue_1), " ", "_");
+    }
+  } else {
+    return URIModule_toString(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", list(singleton({
+    Encode(helpers_1) {
+      return helpers_1.encodeString("Data");
+    }
+  }))], tryInclude("name", (value_2) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_2);
+    }
+  }), oa.Name), tryInclude("type", ROCrate_encoder$1, oa.DataType), tryInclude("encodingFormat", (value_5) => ({
+    Encode(helpers_3) {
+      return helpers_3.encodeString(value_5);
+    }
+  }), oa.Format), tryInclude("usageInfo", (value_7) => ({
+    Encode(helpers_4) {
+      return helpers_4.encodeString(value_7);
+    }
+  }), oa.SelectorFormat), tryIncludeSeq("comments", ROCrate_encoder$2, 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 Data(unwrap((objectArg = get$.Optional, objectArg.Field("@id", Decode_uri))), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("name", string))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("type", ROCrate_decoder$1))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("encodingFormat", string))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("usageInfo", Decode_uri))), unwrap((arg_11 = resizeArray(ROCrate_decoder$2), objectArg_5 = get$.Optional, objectArg_5.Field("comments", arg_11))));
+});
+function ISAJson_encoder(idMap, oa) {
+  const f = (oa_1) => {
+    const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([tryInclude("@id", (value) => ({
+      Encode(helpers) {
+        return helpers.encodeString(value);
+      }
+    }), ROCrate_genID(oa_1)), tryInclude("name", (value_2) => ({
+      Encode(helpers_1) {
+        return helpers_1.encodeString(value_2);
+      }
+    }), oa_1.Name), tryInclude("type", ISAJson_encoder$1, oa_1.DataType), tryIncludeSeq("comments", (comment) => ISAJson_encoder$2(idMap, comment), oa_1.Comments)]));
+    return {
+      Encode(helpers_2) {
+        const arg = map$1((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_2)], values_1);
+        return helpers_2.encodeObject(arg);
+      }
+    };
+  };
+  if (idMap != null) {
+    return encode(ROCrate_genID, f, oa, value(idMap));
+  } else {
+    return f(oa);
+  }
+}
+const ISAJson_allowedFields = ofArray(["@id", "name", "type", "comments", "@type", "@context"]);
+const ISAJson_decoder = Decode_objectNoAdditionalProperties(ISAJson_allowedFields, (get$) => {
+  let objectArg, objectArg_1, objectArg_2, arg_7, objectArg_3;
+  return new Data(unwrap((objectArg = get$.Optional, objectArg.Field("@id", Decode_uri))), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("name", string))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("type", ISAJson_decoder$1))), void 0, void 0, unwrap((arg_7 = resizeArray(ISAJson_decoder$2), objectArg_3 = get$.Optional, objectArg_3.Field("comments", arg_7))));
+});
+
+export { ISAJson_allowedFields, ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_encoder, ROCrate_genID, compressedDecoder, compressedEncoder, decoder, encoder };

package/dist/ts/ts/Json/DataFile.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 { DataFile_$union } from '../Core/DataFile.js';
 export declare function ROCrate_encoder(value: DataFile_$union): IEncodable;
 export declare const ROCrate_decoder: Decoder$1<DataFile_$union>;

package/dist/ts/ts/Json/DataFile.js

@@ -0,0 +1,55 @@
+import { ErrorReason$1_BadPrimitive } from '../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
+import { DataFile_ImageFile, DataFile_DerivedDataFile, DataFile_RawDataFile } from '../Core/DataFile.js';
+import { string } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok } from '../../node_modules/@fable-org/fable-library-js/Result.js';
+
+function ROCrate_encoder(value) {
+  switch (value.tag) {
+    case /* DerivedDataFile */
+    1:
+      return {
+        Encode(helpers_1) {
+          return helpers_1.encodeString("Derived Data File");
+        }
+      };
+    case /* ImageFile */
+    2:
+      return {
+        Encode(helpers_2) {
+          return helpers_2.encodeString("Image File");
+        }
+      };
+    default:
+      return {
+        Encode(helpers) {
+          return helpers.encodeString("Raw Data File");
+        }
+      };
+  }
+}
+const ROCrate_decoder = {
+  Decode(s, json) {
+    const matchValue = string.Decode(s, json);
+    if (matchValue.tag === /* Error */
+    1) {
+      return FSharpResult$2_Error(matchValue.fields[0]);
+    } else {
+      switch (matchValue.fields[0]) {
+        case "Raw Data File":
+          return FSharpResult$2_Ok(DataFile_RawDataFile());
+        case "Derived Data File":
+          return FSharpResult$2_Ok(DataFile_DerivedDataFile());
+        case "Image File":
+          return FSharpResult$2_Ok(DataFile_ImageFile());
+        default: {
+          const s_1 = matchValue.fields[0];
+          return FSharpResult$2_Error([`Could not parse ${s_1}.`, ErrorReason$1_BadPrimitive(s_1, json)]);
+        }
+      }
+    }
+  }
+};
+const ISAJson_encoder = ROCrate_encoder;
+const ISAJson_decoder = ROCrate_decoder;
+
+export { ISAJson_decoder, ISAJson_encoder, ROCrate_decoder, ROCrate_encoder };

package/dist/ts/ts/Json/DataMap/DataContext.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 { DataContext } from '../../Core/DataContext.js';
 export declare function encoder(dc: DataContext): IEncodable;
 export declare const decoder: Decoder$1<DataContext>;

package/dist/ts/ts/Json/DataMap/DataContext.js

@@ -0,0 +1,39 @@
+import { choose, ofArray } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { unwrap, map } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { decoder as decoder$1, encoder as encoder$1 } from '../Data.js';
+import { tryInclude } from '../Encode.js';
+import { OntologyAnnotation_decoder, OntologyAnnotation_encoder } from '../OntologyAnnotation.js';
+import { DataContext_$ctor_Z780A8A2A, DataContext__get_Explication, DataContext__get_Unit, DataContext__get_ObjectType, DataContext__get_Description, DataContext__get_GeneratedBy, DataContext__get_Label } from '../../Core/DataContext.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';
+
+function encoder(dc) {
+  const values_1 = choose((tupledArg) => map((v_1) => [tupledArg[0], v_1], tupledArg[1]), ofArray([["data", encoder$1(dc)], tryInclude("explication", OntologyAnnotation_encoder, DataContext__get_Explication(dc)), tryInclude("unit", OntologyAnnotation_encoder, DataContext__get_Unit(dc)), tryInclude("objectType", OntologyAnnotation_encoder, DataContext__get_ObjectType(dc)), tryInclude("description", (value) => ({
+    Encode(helpers) {
+      return helpers.encodeString(value);
+    }
+  }), DataContext__get_Description(dc)), tryInclude("generatedBy", (value_2) => ({
+    Encode(helpers_1) {
+      return helpers_1.encodeString(value_2);
+    }
+  }), DataContext__get_GeneratedBy(dc)), tryInclude("label", (value_4) => ({
+    Encode(helpers_2) {
+      return helpers_2.encodeString(value_4);
+    }
+  }), DataContext__get_Label(dc))]));
+  return {
+    Encode(helpers_3) {
+      const arg = map$1((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_3)], values_1);
+      return helpers_3.encodeObject(arg);
+    }
+  };
+}
+const decoder = object((get$) => {
+  let objectArg_1, objectArg_2, objectArg_3, objectArg_4, objectArg_5, objectArg_6;
+  let data;
+  const objectArg = get$.Required;
+  data = objectArg.Field("data", decoder$1);
+  return DataContext_$ctor_Z780A8A2A(unwrap(data.ID), unwrap(data.Name), unwrap(data.DataType), unwrap(data.Format), unwrap(data.SelectorFormat), unwrap((objectArg_1 = get$.Optional, objectArg_1.Field("explication", OntologyAnnotation_decoder))), unwrap((objectArg_2 = get$.Optional, objectArg_2.Field("unit", OntologyAnnotation_decoder))), unwrap((objectArg_3 = get$.Optional, objectArg_3.Field("objectType", OntologyAnnotation_decoder))), unwrap((objectArg_4 = get$.Optional, objectArg_4.Field("label", string))), unwrap((objectArg_5 = get$.Optional, objectArg_5.Field("description", string))), unwrap((objectArg_6 = get$.Optional, objectArg_6.Field("generatedBy", string))), data.Comments);
+});
+
+export { decoder, encoder };

package/dist/ts/ts/Json/DataMap/DataMap.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 { DataMap } from '../../Core/DataMap.js';
 import { IMap } from '@fable-org/fable-library-js/Util.js';
 import { int32 } from '@fable-org/fable-library-js/Int32.js';

package/dist/ts/ts/Json/DataMap/DataMap.js

@@ -0,0 +1,27 @@
+import { seq } from '../../fable_modules/Thoth.Json.Core.0.7.0/Encode.fs.js';
+import { map } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { decoder as decoder$1, encoder as encoder$1 } from './DataContext.js';
+import { DataMap_$ctor_4E3220A7, DataMap__get_DataContexts } from '../../Core/DataMap.js';
+import { object, resizeArray } from '../../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+
+function encoder(dm) {
+  const values_1 = [["dataContexts", seq(map(encoder$1, DataMap__get_DataContexts(dm)))]];
+  return {
+    Encode(helpers) {
+      const arg = map((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values_1);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
+const decoder = object((get$) => {
+  let arg_1, objectArg;
+  return DataMap_$ctor_4E3220A7((arg_1 = resizeArray(decoder$1), objectArg = get$.Required, objectArg.Field("dataContexts", arg_1)));
+});
+function encoderCompressed(stringTable, oaTable, cellTable, dm) {
+  return encoder(dm);
+}
+function decoderCompressed(stringTable, oaTable, cellTable) {
+  return decoder;
+}
+
+export { decoder, decoderCompressed, encoder, encoderCompressed };

package/dist/ts/ts/Json/Decode.d.ts

@@ -1,5 +1,5 @@
-import { Decoder$1, IDecoderHelpers$1, ErrorReason$1_$union } from '../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
-import { IGetters } from '../fable_modules/Thoth.Json.Core.0.4.0/Decode.fs.js';
+import { Decoder$1, IDecoderHelpers$1, ErrorReason$1_$union } from '../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
+import { IGetters } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
 import { FSharpSet } from '@fable-org/fable-library-js/Set.js';
 import { IMap } from '@fable-org/fable-library-js/Util.js';
 import { int32 } from '@fable-org/fable-library-js/Int32.js';

package/dist/ts/ts/Json/Decode.js

@@ -0,0 +1,209 @@
+import { ErrorReason$1_BadPrimitive, ErrorReason$1_BadOneOf, ErrorReason$1_FailMessage } from '../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
+import { Getters$2_$ctor_Z4BE6C149, Getters$2__get_Errors, tuple2, string, int } from '../fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { FSharpResult$2_Ok, FSharpResult$2_Error, Result_Map } from '../../node_modules/@fable-org/fable-library-js/Result.js';
+import { exists } from '../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { ofSeq, contains } from '../../node_modules/@fable-org/fable-library-js/Set.js';
+import { int32ToString, structuralHash, equals, comparePrimitives } from '../../node_modules/@fable-org/fable-library-js/Util.js';
+import { isEmpty, length, head, empty, cons, tail } from '../../node_modules/@fable-org/fable-library-js/List.js';
+import { fold } from '../../node_modules/@fable-org/fable-library-js/Array.js';
+import { minValue, tryParse } from '../../node_modules/@fable-org/fable-library-js/Date.js';
+import { FSharpRef } from '../../node_modules/@fable-org/fable-library-js/Types.js';
+import { Dictionary } from '../../node_modules/@fable-org/fable-library-js/MutableMap.js';
+import { addToDict } from '../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+
+function Helpers_prependPath(path, err_, err__1) {
+  const err = [err_, err__1];
+  return [path + err[0], err[1]];
+}
+function Decode_isURI(s) {
+  return true;
+}
+const Decode_uri = {
+  Decode(s, json) {
+    const matchValue = string.Decode(s, json);
+    if (matchValue.tag === /* Error */
+    1) {
+      return FSharpResult$2_Error(matchValue.fields[0]);
+    } else if (Decode_isURI(matchValue.fields[0])) {
+      return FSharpResult$2_Ok(matchValue.fields[0]);
+    } else ;
+  }
+};
+function Decode_hasUnknownFields(helpers, knownFields, json) {
+  return exists((x) => !contains(x, knownFields), helpers.getProperties(json));
+}
+function Decode_objectNoAdditionalProperties(allowedProperties, builder) {
+  const allowedProperties_1 = ofSeq(allowedProperties, {
+    Compare: comparePrimitives
+  });
+  return {
+    Decode(helpers, value) {
+      const getters = Getters$2_$ctor_Z4BE6C149(helpers, value);
+      if (Decode_hasUnknownFields(helpers, allowedProperties_1, value)) {
+        return FSharpResult$2_Error(["Unknown fields in object", ErrorReason$1_BadPrimitive("", value)]);
+      } else {
+        const result = builder(getters);
+        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);
+        }
+      }
+    }
+  };
+}
+function Decode_noAdditionalProperties(allowedProperties, decoder) {
+  const allowedProperties_1 = ofSeq(allowedProperties, {
+    Compare: comparePrimitives
+  });
+  return {
+    Decode(helpers, value) {
+      Getters$2_$ctor_Z4BE6C149(helpers, value);
+      return Decode_hasUnknownFields(helpers, allowedProperties_1, value) ? FSharpResult$2_Error(["Unknown fields in object", ErrorReason$1_BadPrimitive("", value)]) : decoder.Decode(helpers, value);
+    }
+  };
+}
+function Decode_resizeArrayOrSingleton(decoder) {
+  return {
+    Decode(helpers, value) {
+      if (helpers.isArray(value)) {
+        let i = -1;
+        return fold((acc, value_1) => {
+          let tupledArg;
+          i = i + 1 | 0;
+          if (acc.tag === /* Ok */
+          0) {
+            const acc_1 = acc.fields[0];
+            const matchValue = decoder.Decode(helpers, value_1);
+            if (matchValue.tag === /* Ok */
+            0) {
+              const value_2 = matchValue.fields[0];
+              void acc_1.push(value_2);
+              return FSharpResult$2_Ok(acc_1);
+            } else {
+              return FSharpResult$2_Error((tupledArg = matchValue.fields[0], Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1])));
+            }
+          } else {
+            return acc;
+          }
+        }, FSharpResult$2_Ok([]), helpers.asArray(value));
+      } else {
+        return Result_Map((x) => [x], decoder.Decode(helpers, value));
+      }
+    }
+  };
+}
+const Decode_datetime = {
+  Decode(helpers, value) {
+    if (helpers.isString(value)) {
+      let matchValue;
+      let outArg = minValue();
+      matchValue = [tryParse(helpers.asString(value), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value)]);
+    }
+  }
+};
+function Decode_dictionary(keyDecoder, valueDecoder) {
+  return {
+    Decode(helpers, value) {
+      if (helpers.isArray(value)) {
+        empty();
+        const tokens = helpers.asArray(value);
+        const dict = new Dictionary([], {
+          Equals: equals,
+          GetHashCode: structuralHash
+        });
+        const decoder = tuple2(keyDecoder, valueDecoder);
+        return fold((acc, value_1) => {
+          if (acc.tag === /* Ok */
+          0) {
+            const acc_1 = acc.fields[0];
+            const matchValue = decoder.Decode(helpers, value_1);
+            if (matchValue.tag === /* Ok */
+            0) {
+              const tupledArg = matchValue.fields[0];
+              addToDict(acc_1, tupledArg[0], tupledArg[1]);
+              return FSharpResult$2_Ok(acc_1);
+            } else {
+              return FSharpResult$2_Error(matchValue.fields[0]);
+            }
+          } else {
+            return acc;
+          }
+        }, FSharpResult$2_Ok(dict), tokens);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value)]);
+      }
+    }
+  };
+}
+function Decode_intDictionary(valueDecoder) {
+  return {
+    Decode(helpers, value) {
+      if (helpers.isArray(value)) {
+        empty();
+        const tokens = helpers.asArray(value);
+        const dict = /* @__PURE__ */ new Map([]);
+        const decoder = tuple2(int, valueDecoder);
+        return fold((acc, value_1) => {
+          if (acc.tag === /* Ok */
+          0) {
+            const acc_1 = acc.fields[0];
+            const matchValue = decoder.Decode(helpers, value_1);
+            if (matchValue.tag === /* Ok */
+            0) {
+              const tupledArg = matchValue.fields[0];
+              addToDict(acc_1, tupledArg[0], tupledArg[1]);
+              return FSharpResult$2_Ok(acc_1);
+            } else {
+              return FSharpResult$2_Error(matchValue.fields[0]);
+            }
+          } else {
+            return acc;
+          }
+        }, FSharpResult$2_Ok(dict), tokens);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value)]);
+      }
+    }
+  };
+}
+function Decode_tryOneOf(decoders) {
+  return {
+    Decode(helpers, value) {
+      const loop = (errors_mut, decoders_1_mut) => {
+        loop:
+          while (true) {
+            const errors = errors_mut, decoders_1 = decoders_1_mut;
+            if (!isEmpty(decoders_1)) {
+              let decodingResult;
+              try {
+                decodingResult = head(decoders_1).Decode(helpers, value);
+              } catch (e) {
+                decodingResult = FSharpResult$2_Error(["", ErrorReason$1_FailMessage(e.message)]);
+              }
+              if (decodingResult.tag === /* Error */
+              1) {
+                errors_mut = cons(decodingResult.fields[0], errors);
+                decoders_1_mut = tail(decoders_1);
+                continue loop;
+              } else {
+                return FSharpResult$2_Ok(decodingResult.fields[0]);
+              }
+            } else {
+              return FSharpResult$2_Error(["", ErrorReason$1_BadOneOf(errors)]);
+            }
+          }
+      };
+      return loop(empty(), decoders);
+    }
+  };
+}
+
+export { Decode_datetime, Decode_dictionary, Decode_hasUnknownFields, Decode_intDictionary, Decode_isURI, Decode_noAdditionalProperties, Decode_objectNoAdditionalProperties, Decode_resizeArrayOrSingleton, Decode_tryOneOf, Decode_uri, Helpers_prependPath };

package/dist/ts/ts/Json/Encode.d.ts

@@ -1,5 +1,5 @@
 import { Option } from '@fable-org/fable-library-js/Option.js';
-import { Json_$union, IEncodable } from '../fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js';
+import { Json_$union, IEncodable } from '../fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js';
 import { FSharpList } from '@fable-org/fable-library-js/List.js';
 import { int32 } from '@fable-org/fable-library-js/Int32.js';
 /**