@nfdi4plants/arctrl 3.0.0-beta.5 → 3.0.0-beta.6

package/dist/ts/ts/fable_modules/Thoth.Json.Core.0.7.0/Encode.fs.js

@@ -1,11 +1,22 @@
-import { map } from '../../../node_modules/@fable-org/fable-library-js/List.js';
-import { map as map$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
-import { map as map$2 } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { map as map$1 } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { map as map$2 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { toSeq, toList } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+import { map as map$3 } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { defaultArgWith, map as map$4, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
 
+function float32(value) {
+  const value_1 = value;
+  return {
+    Encode(helpers) {
+      return helpers.encodeDecimalNumber(value_1);
+    }
+  };
+}
 function list(values) {
   return {
     Encode(helpers) {
-      const arg = map((v) => v.Encode(helpers), values);
+      const arg = map$1((v) => v.Encode(helpers), values);
       return helpers.encodeList(arg);
     }
   };
@@ -13,19 +24,193 @@ function list(values) {
 function seq(values) {
   return {
     Encode(helpers) {
-      const arg = map$1((v) => v.Encode(helpers), values);
+      const arg = map$2((v) => v.Encode(helpers), values);
       return helpers.encodeSeq(arg);
     }
   };
 }
+function resizeArray(values) {
+  return {
+    Encode(helpers) {
+      const result = [];
+      let enumerator = getEnumerator(values);
+      try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+          const v = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+          void result.push(v.Encode(helpers));
+        }
+      } finally {
+        disposeSafe(enumerator);
+      }
+      return helpers.encodeResizeArray(result);
+    }
+  };
+}
+function dict(values) {
+  const values_1 = toSeq(values);
+  return {
+    Encode(helpers) {
+      const arg = map$2((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers)], values_1);
+      return helpers.encodeObject(arg);
+    }
+  };
+}
 function tuple2(enc1, enc2, v1, v2) {
   const values = [enc1(v1), enc2(v2)];
   return {
     Encode(helpers) {
-      const arg = map$2((v) => v.Encode(helpers), values);
+      const arg = map$3((v) => v.Encode(helpers), values);
+      return helpers.encodeArray(arg);
+    }
+  };
+}
+function tuple3(enc1, enc2, enc3, v1, v2, v3) {
+  const values = [enc1(v1), enc2(v2), enc3(v3)];
+  return {
+    Encode(helpers) {
+      const arg = map$3((v) => v.Encode(helpers), values);
+      return helpers.encodeArray(arg);
+    }
+  };
+}
+function tuple4(enc1, enc2, enc3, enc4, v1, v2, v3, v4) {
+  const values = [enc1(v1), enc2(v2), enc3(v3), enc4(v4)];
+  return {
+    Encode(helpers) {
+      const arg = map$3((v) => v.Encode(helpers), values);
+      return helpers.encodeArray(arg);
+    }
+  };
+}
+function tuple5(enc1, enc2, enc3, enc4, enc5, v1, v2, v3, v4, v5) {
+  const values = [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5)];
+  return {
+    Encode(helpers) {
+      const arg = map$3((v) => v.Encode(helpers), values);
+      return helpers.encodeArray(arg);
+    }
+  };
+}
+function tuple6(enc1, enc2, enc3, enc4, enc5, enc6, v1, v2, v3, v4, v5, v6) {
+  const values = [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6)];
+  return {
+    Encode(helpers) {
+      const arg = map$3((v) => v.Encode(helpers), values);
+      return helpers.encodeArray(arg);
+    }
+  };
+}
+function tuple7(enc1, enc2, enc3, enc4, enc5, enc6, enc7, v1, v2, v3, v4, v5, v6, v7) {
+  const values = [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6), enc7(v7)];
+  return {
+    Encode(helpers) {
+      const arg = map$3((v) => v.Encode(helpers), values);
+      return helpers.encodeArray(arg);
+    }
+  };
+}
+function tuple8(enc1, enc2, enc3, enc4, enc5, enc6, enc7, enc8, v1, v2, v3, v4, v5, v6, v7, v8) {
+  const values = [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6), enc7(v7), enc8(v8)];
+  return {
+    Encode(helpers) {
+      const arg = map$3((v) => v.Encode(helpers), values);
       return helpers.encodeArray(arg);
     }
   };
 }
+function map(keyEncoder, valueEncoder, values) {
+  return list(map$1((tupledArg) => tuple2(keyEncoder, valueEncoder, tupledArg[0], tupledArg[1]), toList(values)));
+}
+function Enum_byte(value) {
+  const value_1 = value;
+  return {
+    Encode(helpers) {
+      return helpers.encodeUnsignedIntegralNumber(value_1);
+    }
+  };
+}
+function Enum_sbyte(value) {
+  const value_1 = value | 0;
+  return {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value_1);
+    }
+  };
+}
+function Enum_int16(value) {
+  const value_1 = value | 0;
+  return {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value_1);
+    }
+  };
+}
+function Enum_uint16(value) {
+  const value_1 = value;
+  return {
+    Encode(helpers) {
+      return helpers.encodeUnsignedIntegralNumber(value_1);
+    }
+  };
+}
+function Enum_int(value) {
+  const value_1 = value | 0;
+  return {
+    Encode(helpers) {
+      return helpers.encodeSignedIntegralNumber(value_1);
+    }
+  };
+}
+function Enum_uint32(value) {
+  const value_1 = value;
+  return {
+    Encode(helpers) {
+      return helpers.encodeUnsignedIntegralNumber(value_1);
+    }
+  };
+}
+function lossyOption(encoder) {
+  return (arg) => defaultArgWith(map$4(encoder, arg), () => ({
+    Encode(helpers) {
+      return helpers.encodeNull();
+    }
+  }));
+}
+function losslessOption(encoder, value$1) {
+  if (value$1 == null) {
+    const values_1 = [["$type", {
+      Encode(helpers_3) {
+        return helpers_3.encodeString("option");
+      }
+    }], ["$case", {
+      Encode(helpers_4) {
+        return helpers_4.encodeString("none");
+      }
+    }]];
+    return {
+      Encode(helpers_5) {
+        const arg_1 = map$2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_5)], values_1);
+        return helpers_5.encodeObject(arg_1);
+      }
+    };
+  } else {
+    const v = value(value$1);
+    const values = [["$type", {
+      Encode(helpers) {
+        return helpers.encodeString("option");
+      }
+    }], ["$case", {
+      Encode(helpers_1) {
+        return helpers_1.encodeString("some");
+      }
+    }], ["$value", encoder(v)]];
+    return {
+      Encode(helpers_2) {
+        const arg = map$2((tupledArg) => [tupledArg[0], tupledArg[1].Encode(helpers_2)], values);
+        return helpers_2.encodeObject(arg);
+      }
+    };
+  }
+}
 
-export { list, seq, tuple2 };
+export { Enum_byte, Enum_int, Enum_int16, Enum_sbyte, Enum_uint16, Enum_uint32, dict, float32, list, losslessOption, lossyOption, map, resizeArray, seq, tuple2, tuple3, tuple4, tuple5, tuple6, tuple7, tuple8 };

package/dist/ts/ts/fable_modules/Thoth.Json.Core.0.7.0/Types.fs.js

@@ -1,4 +1,5 @@
 import { Union } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { union_type, string_type, list_type, tuple_type, char_type, float64_type, bool_type, class_type, array_type, uint32_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
 
 function ErrorReason$1_BadPrimitive(Item1, Item2) {
   return new ErrorReason$1(0, [Item1, Item2]);
@@ -34,5 +35,48 @@ class ErrorReason$1 extends Union {
     return ["BadPrimitive", "BadPrimitiveExtra", "BadType", "BadField", "BadPath", "TooSmallArray", "FailMessage", "BadOneOf"];
   }
 }
+function ErrorReason$1_$reflection(gen0) {
+  return union_type("Thoth.Json.Core.ErrorReason`1", [gen0], ErrorReason$1, () => [[["Item1", string_type], ["Item2", gen0]], [["Item1", string_type], ["Item2", gen0], ["Item3", string_type]], [["Item1", string_type], ["Item2", gen0]], [["Item1", string_type], ["Item2", gen0]], [["Item1", string_type], ["Item2", gen0], ["Item3", string_type]], [["Item1", string_type], ["Item2", gen0]], [["Item", string_type]], [["Item", list_type(tuple_type(string_type, ErrorReason$1_$reflection(gen0)))]]]);
+}
+function Json_String(Item) {
+  return new Json(0, [Item]);
+}
+function Json_Char(Item) {
+  return new Json(1, [Item]);
+}
+function Json_DecimalNumber(Item) {
+  return new Json(2, [Item]);
+}
+function Json_Null() {
+  return new Json(3, []);
+}
+function Json_Boolean(Item) {
+  return new Json(4, [Item]);
+}
+function Json_Object(Item) {
+  return new Json(5, [Item]);
+}
+function Json_Array(Item) {
+  return new Json(6, [Item]);
+}
+function Json_IntegralNumber(Item) {
+  return new Json(7, [Item]);
+}
+function Json_Unit() {
+  return new Json(8, []);
+}
+class Json extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["String", "Char", "DecimalNumber", "Null", "Boolean", "Object", "Array", "IntegralNumber", "Unit"];
+  }
+}
+function Json_$reflection() {
+  return union_type("Thoth.Json.Core.Json", [], Json, () => [[["Item", string_type]], [["Item", char_type]], [["Item", float64_type]], [], [["Item", bool_type]], [["Item", class_type("System.Collections.Generic.IEnumerable`1", [tuple_type(string_type, Json_$reflection())])]], [["Item", array_type(Json_$reflection())]], [["Item", uint32_type]], []]);
+}
 
-export { ErrorReason$1, ErrorReason$1_BadField, ErrorReason$1_BadOneOf, ErrorReason$1_BadPath, ErrorReason$1_BadPrimitive, ErrorReason$1_BadPrimitiveExtra, ErrorReason$1_BadType, ErrorReason$1_FailMessage, ErrorReason$1_TooSmallArray };
+export { ErrorReason$1, ErrorReason$1_$reflection, ErrorReason$1_BadField, ErrorReason$1_BadOneOf, ErrorReason$1_BadPath, ErrorReason$1_BadPrimitive, ErrorReason$1_BadPrimitiveExtra, ErrorReason$1_BadType, ErrorReason$1_FailMessage, ErrorReason$1_TooSmallArray, Json, Json_$reflection, Json_Array, Json_Boolean, Json_Char, Json_DecimalNumber, Json_IntegralNumber, Json_Null, Json_Object, Json_String, Json_Unit };

package/dist/ts/ts/fable_modules/Thoth.Json.JavaScript.0.4.1/Decode.fs.js

@@ -1,4 +1,4 @@
-import { Helpers_prependPath, errorToString } from '../Thoth.Json.Core.0.7.0/Decode.fs.js';
+import { Advanced_fromValue, Helpers_prependPath, errorToString } from '../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';
 
 const helpers = {
@@ -22,6 +22,7 @@ const helpers = {
   },
   hasProperty(fieldName, jsonValue_6) {
     return jsonValue_6.hasOwnProperty(fieldName);
+    ;
   },
   isIntegralValue(jsonValue_7) {
     return isFinite(jsonValue_7) && Math.floor(jsonValue_7) === jsonValue_7;
@@ -54,6 +55,9 @@ const helpers = {
     return JSON.stringify(jsonValue_16, null, 4) + "";
   }
 };
+function fromValue(decoder) {
+  return (value) => Advanced_fromValue(helpers, decoder, value);
+}
 function fromString(decoder, value) {
   try {
     const json = JSON.parse(value);
@@ -75,5 +79,14 @@ function fromString(decoder, value) {
     }
   }
 }
+function unsafeFromString(decoder, value) {
+  const matchValue = fromString(decoder, value);
+  if (matchValue.tag === /* Error */
+  1) {
+    throw new Error(matchValue.fields[0]);
+  } else {
+    return matchValue.fields[0];
+  }
+}
 
-export { fromString, helpers };
+export { fromString, fromValue, helpers, unsafeFromString };