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

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

@@ -0,0 +1,544 @@
+import { ErrorReason$1_BadOneOf, ErrorReason$1_BadPrimitive, ErrorReason$1_BadPrimitiveExtra, ErrorReason$1_TooSmallArray, ErrorReason$1_BadType, ErrorReason$1_BadField, ErrorReason$1_BadPath } from './Types.fs.js';
+import { join } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { empty, isEmpty, head, tail, append, singleton, length, map as map$1, fold as fold$1, tryLast } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok, Result_MapError } from '../../../node_modules/@fable-org/fable-library-js/Result.js';
+import { tryParse as tryParse$2 } from '../../../node_modules/@fable-org/fable-library-js/Guid.js';
+import { FSharpRef } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { tryParse } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { tryParse as tryParse$1 } from '../../../node_modules/@fable-org/fable-library-js/Decimal.js';
+import { some, value, defaultArg } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { defaultOf, int32ToString, compare } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { item, fold, fill, setItem } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { toList } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { ofSeq } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+import { Big } from '../../../node_modules/@fable-org/fable-library-js/lib/big.js';
+
+function Helpers_prependPath(path, err_, err__1) {
+  const err = [err_, err__1];
+  return [path + err[0], err[1]];
+}
+function genericMsg(helpers, msg, value_1, newLine) {
+  try {
+    return "Expecting " + msg + " but instead got:" + (newLine ? "\n" : " ") + helpers.anyToString(value_1);
+  } catch (matchValue) {
+    return "Expecting " + msg + " but decoder failed. Couldn't report given value due to circular structure." + (newLine ? "\n" : " ");
+  }
+}
+function errorToString(helpers, path, error) {
+  let reason_1;
+  switch (error.tag) {
+    case /* BadType */
+    2: {
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], true);
+      break;
+    }
+    case /* BadPrimitiveExtra */
+    1: {
+      const reason = error.fields[2];
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], false) + "\nReason: " + reason;
+      break;
+    }
+    case /* BadField */
+    3: {
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], true);
+      break;
+    }
+    case /* BadPath */
+    4: {
+      const fieldName = error.fields[2];
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], true) + ("\nNode `" + fieldName + "` is unkown.");
+      break;
+    }
+    case /* TooSmallArray */
+    5: {
+      const value_6 = error.fields[1];
+      reason_1 = "Expecting " + error.fields[0] + ".\n" + helpers.anyToString(value_6);
+      break;
+    }
+    case /* BadOneOf */
+    7: {
+      reason_1 = "The following errors were found:\n\n" + join("\n\n", map$1((error_1) => {
+        const tupledArg = Helpers_prependPath(path, error_1[0], error_1[1]);
+        return errorToString(helpers, tupledArg[0], tupledArg[1]);
+      }, error.fields[0]));
+      break;
+    }
+    case /* FailMessage */
+    6: {
+      reason_1 = "The following `failure` occurred with the decoder: " + error.fields[0];
+      break;
+    }
+    default:
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], false);
+  }
+  if (error.tag === /* BadOneOf */
+  7) {
+    return reason_1;
+  } else {
+    return "Error at: `" + path + "`\n" + reason_1;
+  }
+}
+const string = {
+  Decode(helpers, value_1) {
+    return helpers.isString(value_1) ? FSharpResult$2_Ok(helpers.asString(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a string", value_1)]);
+  }
+};
+const guid = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = "00000000-0000-0000-0000-000000000000";
+      matchValue = [tryParse$2(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a guid", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a guid", value_1)]);
+    }
+  }
+};
+const unit = {
+  Decode(helpers, value_1) {
+    return helpers.isNullValue(value_1) ? FSharpResult$2_Ok(void 0) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("null", value_1)]);
+  }
+};
+const int = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return -2147483648 <= floatValue && floatValue <= 2147483647 ? FSharpResult$2_Ok(~~floatValue) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int", value_2, "Value was either too large or too small for an int")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse(helpers.asString(value_2), 511, false, 32, new FSharpRef(() => outArg, (v) => {
+        outArg = v | 0;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int", value_2)]);
+    }
+  }
+};
+const bool = {
+  Decode(helpers, value_1) {
+    return helpers.isBoolean(value_1) ? FSharpResult$2_Ok(helpers.asBoolean(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a boolean", value_1)]);
+  }
+};
+const float = {
+  Decode(helpers, value_1) {
+    return helpers.isNumber(value_1) ? FSharpResult$2_Ok(helpers.asFloat(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a float", value_1)]);
+  }
+};
+const decimal = {
+  Decode(helpers, value_1) {
+    if (helpers.isNumber(value_1)) {
+      return FSharpResult$2_Ok(new Big(helpers.asFloat(value_1)));
+    } else if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = new Big("0");
+      matchValue = [tryParse$1(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a decimal", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a decimal", value_1)]);
+    }
+  }
+};
+function decodeMaybeNull(helpers, path, decoder, value_1) {
+  let tupledArg;
+  if (helpers.isNullValue(value_1)) {
+    return FSharpResult$2_Ok(void 0);
+  } else {
+    const matchValue = decoder.Decode(helpers, value_1);
+    if (matchValue.tag === /* Error */
+    1) {
+      return FSharpResult$2_Error((tupledArg = matchValue.fields[0], Helpers_prependPath(path, tupledArg[0], tupledArg[1])));
+    } else {
+      return FSharpResult$2_Ok(some(matchValue.fields[0]));
+    }
+  }
+}
+function optional(fieldName, decoder) {
+  return {
+    Decode(helpers, value_1) {
+      return helpers.isObject(value_1) ? helpers.hasProperty(fieldName, value_1) ? decodeMaybeNull(helpers, "." + fieldName, decoder, helpers.getProperty(fieldName, value_1)) : FSharpResult$2_Ok(void 0) : FSharpResult$2_Error(["", ErrorReason$1_BadType("an object", value_1)]);
+    }
+  };
+}
+function badPathError(fieldNames, currentPath, value_1) {
+  return FSharpResult$2_Error(["." + defaultArg(currentPath, join(".", fieldNames)), ErrorReason$1_BadPath("an object with path `" + join(".", fieldNames) + "`", value_1, defaultArg(tryLast(fieldNames), ""))]);
+}
+function optionalAt(fieldNames, decoder) {
+  return {
+    Decode(helpers, firstValue) {
+      const _arg = fold$1((tupledArg, field_1) => {
+        const curPath = tupledArg[0];
+        const curValue = tupledArg[1];
+        const res = tupledArg[2];
+        if (res == null) {
+          if (helpers.isNullValue(curValue)) {
+            return [curPath, curValue, FSharpResult$2_Ok(void 0)];
+          } else if (helpers.isObject(curValue)) {
+            if (helpers.hasProperty(field_1, curValue)) {
+              return [curPath + "." + field_1, helpers.getProperty(field_1, curValue), void 0];
+            } else {
+              return [curPath, curValue, FSharpResult$2_Ok(void 0)];
+            }
+          } else {
+            return [curPath, curValue, FSharpResult$2_Error([curPath, ErrorReason$1_BadType("an object", curValue)])];
+          }
+        } else {
+          return [curPath, curValue, res];
+        }
+      }, ["", firstValue, void 0], fieldNames);
+      if (_arg[2] == null) {
+        const lastValue = _arg[1];
+        return helpers.isNullValue(lastValue) ? FSharpResult$2_Ok(void 0) : decodeMaybeNull(helpers, _arg[0], decoder, lastValue);
+      } else {
+        return value(_arg[2]);
+      }
+    }
+  };
+}
+function field(fieldName, decoder) {
+  return {
+    Decode(helpers, value_1) {
+      if (helpers.isObject(value_1)) {
+        if (helpers.hasProperty(fieldName, value_1)) {
+          const fieldValue = helpers.getProperty(fieldName, value_1);
+          const path = "." + fieldName;
+          return Result_MapError((tupledArg) => Helpers_prependPath(path, tupledArg[0], tupledArg[1]), decoder.Decode(helpers, fieldValue));
+        } else {
+          return FSharpResult$2_Error(["", ErrorReason$1_BadField("an object with a field named `" + fieldName + "`", value_1)]);
+        }
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadType("an object", value_1)]);
+      }
+    }
+  };
+}
+function at(fieldNames, decoder) {
+  return {
+    Decode(helpers, firstValue) {
+      const _arg = fold$1((tupledArg, field_1) => {
+        const curPath = tupledArg[0];
+        const curValue = tupledArg[1];
+        const res = tupledArg[2];
+        if (res == null) {
+          if (helpers.isNullValue(curValue)) {
+            return [curPath, curValue, badPathError(fieldNames, curPath, firstValue)];
+          } else if (helpers.isObject(curValue)) {
+            if (helpers.hasProperty(field_1, curValue)) {
+              return [curPath + "." + field_1, helpers.getProperty(field_1, curValue), void 0];
+            } else {
+              return [curPath, curValue, badPathError(fieldNames, void 0, firstValue)];
+            }
+          } else {
+            return [curPath, curValue, FSharpResult$2_Error([curPath, ErrorReason$1_BadType("an object", curValue)])];
+          }
+        } else {
+          return [curPath, curValue, res];
+        }
+      }, ["", firstValue, void 0], fieldNames);
+      return _arg[2] == null ? Result_MapError((tupledArg_1) => Helpers_prependPath(_arg[0], tupledArg_1[0], tupledArg_1[1]), decoder.Decode(helpers, _arg[1])) : value(_arg[2]);
+    }
+  };
+}
+function index(requestedIndex, decoder) {
+  return {
+    Decode(helpers, value_1) {
+      if (helpers.isArray(value_1)) {
+        const vArray = helpers.asArray(value_1);
+        const path = ".[" + int32ToString(requestedIndex) + "]";
+        return requestedIndex < vArray.length ? Result_MapError((tupledArg) => Helpers_prependPath(path, tupledArg[0], tupledArg[1]), decoder.Decode(helpers, item(requestedIndex, vArray))) : FSharpResult$2_Error([path, ErrorReason$1_TooSmallArray("a longer array. Need index `" + int32ToString(requestedIndex) + "` but there are only `" + int32ToString(vArray.length) + "` entries", value_1)]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an array", value_1)]);
+      }
+    }
+  };
+}
+function list(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      let tupledArg;
+      if (helpers.isArray(value_1)) {
+        const tokens = helpers.asArray(value_1);
+        let i = 0;
+        let result = empty();
+        let error = void 0;
+        while (i < tokens.length && error == null) {
+          const value_2 = item(i, tokens);
+          const matchValue = decoder.Decode(helpers, value_2);
+          if (matchValue.tag === /* Error */
+          1) {
+            const x = (tupledArg = matchValue.fields[0], Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1]));
+            error = x;
+          } else {
+            const value_3 = matchValue.fields[0];
+            result = append(result, singleton(value_3));
+          }
+          i = i + 1 | 0;
+        }
+        return error == null ? FSharpResult$2_Ok(result) : FSharpResult$2_Error(value(error));
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a list", value_1)]);
+      }
+    }
+  };
+}
+function resizeArray(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      let tupledArg;
+      if (helpers.isArray(value_1)) {
+        const tokens = helpers.asArray(value_1);
+        let i = 0;
+        const result = [];
+        let error = void 0;
+        while (i < tokens.length && error == null) {
+          const value_2 = item(i, tokens);
+          const matchValue = decoder.Decode(helpers, value_2);
+          if (matchValue.tag === /* Error */
+          1) {
+            const er = matchValue.fields[0];
+            error = (tupledArg = er, Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1]));
+          } else {
+            const value_3 = matchValue.fields[0];
+            void result.push(value_3);
+          }
+          i = i + 1 | 0;
+        }
+        return error == null ? FSharpResult$2_Ok(Array.from(result)) : FSharpResult$2_Error(value(error));
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a ResizeArray", value_1)]);
+      }
+    }
+  };
+}
+function array(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      if (helpers.isArray(value_1)) {
+        let i = -1;
+        const tokens = helpers.asArray(value_1);
+        return fold((acc, value_2) => {
+          let tupledArg;
+          i = i + 1 | 0;
+          if (acc.tag === /* Ok */
+          0) {
+            const acc_1 = acc.fields[0];
+            const matchValue = decoder.Decode(helpers, value_2);
+            if (matchValue.tag === /* Ok */
+            0) {
+              const value_3 = matchValue.fields[0];
+              setItem(acc_1, i, value_3);
+              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(fill(new Array(tokens.length), 0, tokens.length, null)), tokens);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an array", value_1)]);
+      }
+    }
+  };
+}
+function oneOf(decoders) {
+  return {
+    Decode(helpers, value_1) {
+      const runner = (decoders_1_mut, errors_mut) => {
+        runner:
+          while (true) {
+            const decoders_1 = decoders_1_mut, errors = errors_mut;
+            if (isEmpty(decoders_1)) {
+              return FSharpResult$2_Error(["", ErrorReason$1_BadOneOf(errors)]);
+            } else {
+              const matchValue = head(decoders_1).Decode(helpers, value_1);
+              if (matchValue.tag === /* Error */
+              1) {
+                decoders_1_mut = tail(decoders_1);
+                errors_mut = append(errors, singleton(matchValue.fields[0]));
+                continue runner;
+              } else {
+                return FSharpResult$2_Ok(matchValue.fields[0]);
+              }
+            }
+          }
+      };
+      return runner(decoders, empty());
+    }
+  };
+}
+function succeed(output) {
+  return {
+    Decode(_arg, _arg_1) {
+      return FSharpResult$2_Ok(output);
+    }
+  };
+}
+function andThen(cb, decoder) {
+  return {
+    Decode(helpers, value_1) {
+      const matchValue = decoder.Decode(helpers, value_1);
+      if (matchValue.tag === /* Ok */
+      0) {
+        const result = matchValue.fields[0];
+        return cb(result).Decode(helpers, value_1);
+      } else {
+        return FSharpResult$2_Error(matchValue.fields[0]);
+      }
+    }
+  };
+}
+function map(ctor, d1) {
+  return {
+    Decode(helpers, value_1) {
+      const matchValue = d1.Decode(helpers, value_1);
+      return matchValue.tag === /* Error */
+      1 ? FSharpResult$2_Error(matchValue.fields[0]) : FSharpResult$2_Ok(ctor(matchValue.fields[0]));
+    }
+  };
+}
+function unwrapWith(errors, helpers, decoder, value_1) {
+  const matchValue = decoder.Decode(helpers, value_1);
+  if (matchValue.tag === /* Error */
+  1) {
+    const er = matchValue.fields[0];
+    void errors.push(er);
+    return defaultOf();
+  } else {
+    return matchValue.fields[0];
+  }
+}
+class Getters$2 {
+  constructor(helpers, value_1) {
+    let _this, _this_1;
+    this.errors = [];
+    this.required = (_this = this, {
+      Field(fieldName, decoder) {
+        return unwrapWith(_this.errors, helpers, field(fieldName, decoder), value_1);
+      },
+      At(fieldNames, decoder_1) {
+        return unwrapWith(_this.errors, helpers, at(fieldNames, decoder_1), value_1);
+      },
+      Raw(decoder_2) {
+        return unwrapWith(_this.errors, helpers, decoder_2, value_1);
+      }
+    });
+    this.optional = (_this_1 = this, {
+      Field(fieldName_1, decoder_3) {
+        return unwrapWith(_this_1.errors, helpers, optional(fieldName_1, decoder_3), value_1);
+      },
+      At(fieldNames_1, decoder_4) {
+        return unwrapWith(_this_1.errors, helpers, optionalAt(fieldNames_1, decoder_4), value_1);
+      },
+      Raw(decoder_5) {
+        const matchValue = decoder_5.Decode(helpers, value_1);
+        if (matchValue.tag === /* Error */
+        1) {
+          const reason = matchValue.fields[0][1];
+          const error = matchValue.fields[0];
+          let matchResult, v_1;
+          switch (reason.tag) {
+            case /* BadField */
+            3:
+            case /* BadPath */
+            4: {
+              matchResult = 1;
+              break;
+            }
+            case /* TooSmallArray */
+            5:
+            case /* FailMessage */
+            6:
+            case /* BadOneOf */
+            7: {
+              matchResult = 2;
+              break;
+            }
+            case /* BadPrimitiveExtra */
+            1: {
+              matchResult = 0;
+              v_1 = reason.fields[1];
+              break;
+            }
+            case /* BadType */
+            2: {
+              matchResult = 0;
+              v_1 = reason.fields[1];
+              break;
+            }
+            default: {
+              matchResult = 0;
+              v_1 = reason.fields[1];
+            }
+          }
+          switch (matchResult) {
+            case 0:
+              if (helpers.isNullValue(v_1)) {
+                return void 0;
+              } else {
+                void _this_1.errors.push(error);
+                return defaultOf();
+              }
+            case 1:
+              return void 0;
+            default: {
+              void _this_1.errors.push(error);
+              return defaultOf();
+            }
+          }
+        } else {
+          return some(matchValue.fields[0]);
+        }
+      }
+    });
+  }
+  get Required() {
+    const __ = this;
+    return __.required;
+  }
+  get Optional() {
+    const __ = this;
+    return __.optional;
+  }
+}
+function Getters$2_$ctor_Z4BE6C149(helpers, value_1) {
+  return new Getters$2(helpers, value_1);
+}
+function Getters$2__get_Errors(__) {
+  return toList(__.errors);
+}
+function object(builder) {
+  return {
+    Decode(helpers, value_1) {
+      const getters = Getters$2_$ctor_Z4BE6C149(helpers, value_1);
+      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 tuple2(decoder1, decoder2) {
+  return andThen((v1) => andThen((v2) => succeed([v1, v2]), index(1, decoder2)), index(0, decoder1));
+}
+function map$0027(keyDecoder, valueDecoder) {
+  return map((elements) => ofSeq(elements, {
+    Compare: compare
+  }), array(tuple2(keyDecoder, valueDecoder)));
+}
+
+export { Getters$2, Getters$2_$ctor_Z4BE6C149, Getters$2__get_Errors, Helpers_prependPath, andThen, array, at, bool, decimal, errorToString, field, float, guid, index, int, list, map, map$0027, object, oneOf, optional, optionalAt, resizeArray, string, succeed, tuple2, unit };

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

@@ -0,0 +1,31 @@
+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';
+
+function list(values) {
+  return {
+    Encode(helpers) {
+      const arg = map((v) => v.Encode(helpers), values);
+      return helpers.encodeList(arg);
+    }
+  };
+}
+function seq(values) {
+  return {
+    Encode(helpers) {
+      const arg = map$1((v) => v.Encode(helpers), values);
+      return helpers.encodeSeq(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);
+      return helpers.encodeArray(arg);
+    }
+  };
+}
+
+export { list, seq, tuple2 };

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

@@ -0,0 +1,38 @@
+import { Union } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+
+function ErrorReason$1_BadPrimitive(Item1, Item2) {
+  return new ErrorReason$1(0, [Item1, Item2]);
+}
+function ErrorReason$1_BadPrimitiveExtra(Item1, Item2, Item3) {
+  return new ErrorReason$1(1, [Item1, Item2, Item3]);
+}
+function ErrorReason$1_BadType(Item1, Item2) {
+  return new ErrorReason$1(2, [Item1, Item2]);
+}
+function ErrorReason$1_BadField(Item1, Item2) {
+  return new ErrorReason$1(3, [Item1, Item2]);
+}
+function ErrorReason$1_BadPath(Item1, Item2, Item3) {
+  return new ErrorReason$1(4, [Item1, Item2, Item3]);
+}
+function ErrorReason$1_TooSmallArray(Item1, Item2) {
+  return new ErrorReason$1(5, [Item1, Item2]);
+}
+function ErrorReason$1_FailMessage(Item) {
+  return new ErrorReason$1(6, [Item]);
+}
+function ErrorReason$1_BadOneOf(Item) {
+  return new ErrorReason$1(7, [Item]);
+}
+class ErrorReason$1 extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["BadPrimitive", "BadPrimitiveExtra", "BadType", "BadField", "BadPath", "TooSmallArray", "FailMessage", "BadOneOf"];
+  }
+}
+
+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 };

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

@@ -0,0 +1,79 @@
+import { 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 = {
+  isString(jsonValue) {
+    return typeof jsonValue === "string";
+  },
+  isNumber(jsonValue_1) {
+    return typeof jsonValue_1 === "number";
+  },
+  isBoolean(jsonValue_2) {
+    return typeof jsonValue_2 === "boolean";
+  },
+  isNullValue(jsonValue_3) {
+    return jsonValue_3 == null;
+  },
+  isArray(jsonValue_4) {
+    return Array.isArray(jsonValue_4);
+  },
+  isObject(jsonValue_5) {
+    return jsonValue_5 === null ? false : Object.getPrototypeOf(jsonValue_5 || false) === Object.prototype;
+  },
+  hasProperty(fieldName, jsonValue_6) {
+    return jsonValue_6.hasOwnProperty(fieldName);
+  },
+  isIntegralValue(jsonValue_7) {
+    return isFinite(jsonValue_7) && Math.floor(jsonValue_7) === jsonValue_7;
+  },
+  asString(jsonValue_8) {
+    return jsonValue_8;
+  },
+  asBoolean(jsonValue_9) {
+    return jsonValue_9;
+  },
+  asArray(jsonValue_10) {
+    return jsonValue_10;
+  },
+  asFloat(jsonValue_11) {
+    return jsonValue_11;
+  },
+  asFloat32(jsonValue_12) {
+    return jsonValue_12;
+  },
+  asInt(jsonValue_13) {
+    return jsonValue_13;
+  },
+  getProperties(jsonValue_14) {
+    return Object.keys(jsonValue_14);
+  },
+  getProperty(fieldName_1, jsonValue_15) {
+    return jsonValue_15[fieldName_1];
+  },
+  anyToString(jsonValue_16) {
+    return JSON.stringify(jsonValue_16, null, 4) + "";
+  }
+};
+function fromString(decoder, value) {
+  try {
+    const json = JSON.parse(value);
+    const matchValue = decoder.Decode(helpers, json);
+    if (matchValue.tag === /* Error */
+    1) {
+      let finalError;
+      const tupledArg = matchValue.fields[0];
+      finalError = Helpers_prependPath("$", tupledArg[0], tupledArg[1]);
+      return FSharpResult$2_Error(errorToString(helpers, finalError[0], finalError[1]));
+    } else {
+      return FSharpResult$2_Ok(matchValue.fields[0]);
+    }
+  } catch (matchValue_1) {
+    if (matchValue_1 instanceof SyntaxError) {
+      return FSharpResult$2_Error("Given an invalid JSON: " + matchValue_1.message);
+    } else {
+      throw matchValue_1;
+    }
+  }
+}
+
+export { fromString, helpers };