@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/fable_modules/Thoth.Json.Core.0.4.0/Encode.fs

@@ -1,318 +0,0 @@
-namespace Thoth.Json.Core
-
-open Fable.Core
-open System.Globalization
-open System
-
-[<RequireQualifiedAccess>]
-module Encode =
-
-    let inline string value =
-        { new IEncodable with
-            member _.Encode(helpers) = helpers.encodeString value
-        }
-
-    let inline char value =
-        { new IEncodable with
-            member _.Encode(helpers) = helpers.encodeChar value
-        }
-
-    let inline guid value = value.ToString() |> string
-
-    let inline float value =
-        { new IEncodable with
-            member _.Encode(helpers) = helpers.encodeDecimalNumber value
-        }
-
-    let float32 (value: float32) = float (Operators.float value)
-
-    let inline decimal (value: decimal) =
-        value.ToString(CultureInfo.InvariantCulture) |> string
-
-    let inline nil<'T> =
-        { new IEncodable with
-            member _.Encode(helpers) = helpers.encodeNull ()
-        }
-
-    let inline bool value =
-        { new IEncodable with
-            member _.Encode(helpers) = helpers.encodeBool value
-        }
-
-    let inline object (values: seq<string * IEncodable>) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                values
-                |> Seq.map (fun (k, v) -> (k, v.Encode(helpers)))
-                |> helpers.encodeObject
-        }
-
-    let inline array (values: IEncodable array) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                values
-                |> Array.map (fun v -> v.Encode(helpers))
-                |> helpers.encodeArray
-        }
-
-    let list (values: IEncodable list) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                values
-                |> List.map (fun v -> v.Encode(helpers))
-                |> helpers.encodeList
-        }
-
-    let seq (values: IEncodable seq) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                values
-                |> Seq.map (fun v -> v.Encode(helpers))
-                |> helpers.encodeSeq
-        }
-
-    let resizeArray (values: IEncodable ResizeArray) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                let result = ResizeArray(values.Count)
-
-                for v in values do
-                    result.Add(v.Encode(helpers))
-
-                helpers.encodeResizeArray result
-        }
-
-    let dict (values: Map<string, IEncodable>) : IEncodable =
-        values |> Map.toSeq |> object
-
-    let inline bigint (value: bigint) = value.ToString() |> string
-
-    let inline datetimeOffset (value: DateTimeOffset) =
-        value.ToString("O", CultureInfo.InvariantCulture) |> string
-
-    let inline timespan value = value.ToString() |> string
-
-    let inline datetime (value: DateTime) =
-        value.ToString("O", CultureInfo.InvariantCulture) |> string
-
-    let inline sbyte (value: sbyte) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                helpers.encodeSignedIntegralNumber (int32 value)
-        }
-
-    let inline byte (value: byte) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                helpers.encodeUnsignedIntegralNumber (uint32 value)
-        }
-
-    let inline int16 (value: int16) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                helpers.encodeSignedIntegralNumber (int32 value)
-        }
-
-    let inline uint16 (value: uint16) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                helpers.encodeUnsignedIntegralNumber (uint32 value)
-        }
-
-    let inline int (value: int) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                helpers.encodeSignedIntegralNumber value
-        }
-
-    let inline uint32 (value: uint32) =
-        { new IEncodable with
-            member _.Encode(helpers) =
-                helpers.encodeUnsignedIntegralNumber value
-        }
-
-    let inline int64 (value: int64) =
-        value.ToString(CultureInfo.InvariantCulture) |> string
-
-    let inline uint64 (value: uint64) =
-        value.ToString(CultureInfo.InvariantCulture) |> string
-
-    let inline unit () = nil
-
-    let tuple2 (enc1: Encoder<'T1>) (enc2: Encoder<'T2>) (v1, v2) : IEncodable =
-        array
-            [|
-                enc1 v1
-                enc2 v2
-            |]
-
-    let tuple3
-        (enc1: Encoder<'T1>)
-        (enc2: Encoder<'T2>)
-        (enc3: Encoder<'T3>)
-        (v1, v2, v3)
-        : IEncodable
-        =
-        array
-            [|
-                enc1 v1
-                enc2 v2
-                enc3 v3
-            |]
-
-    let tuple4
-        (enc1: Encoder<'T1>)
-        (enc2: Encoder<'T2>)
-        (enc3: Encoder<'T3>)
-        (enc4: Encoder<'T4>)
-        (v1, v2, v3, v4)
-        : IEncodable
-        =
-        array
-            [|
-                enc1 v1
-                enc2 v2
-                enc3 v3
-                enc4 v4
-            |]
-
-    let tuple5
-        (enc1: Encoder<'T1>)
-        (enc2: Encoder<'T2>)
-        (enc3: Encoder<'T3>)
-        (enc4: Encoder<'T4>)
-        (enc5: Encoder<'T5>)
-        (v1, v2, v3, v4, v5)
-        : IEncodable
-        =
-        array
-            [|
-                enc1 v1
-                enc2 v2
-                enc3 v3
-                enc4 v4
-                enc5 v5
-            |]
-
-    let tuple6
-        (enc1: Encoder<'T1>)
-        (enc2: Encoder<'T2>)
-        (enc3: Encoder<'T3>)
-        (enc4: Encoder<'T4>)
-        (enc5: Encoder<'T5>)
-        (enc6: Encoder<'T6>)
-        (v1, v2, v3, v4, v5, v6)
-        : IEncodable
-        =
-        array
-            [|
-                enc1 v1
-                enc2 v2
-                enc3 v3
-                enc4 v4
-                enc5 v5
-                enc6 v6
-            |]
-
-    let tuple7
-        (enc1: Encoder<'T1>)
-        (enc2: Encoder<'T2>)
-        (enc3: Encoder<'T3>)
-        (enc4: Encoder<'T4>)
-        (enc5: Encoder<'T5>)
-        (enc6: Encoder<'T6>)
-        (enc7: Encoder<'T7>)
-        (v1, v2, v3, v4, v5, v6, v7)
-        : IEncodable
-        =
-        array
-            [|
-                enc1 v1
-                enc2 v2
-                enc3 v3
-                enc4 v4
-                enc5 v5
-                enc6 v6
-                enc7 v7
-            |]
-
-    let tuple8
-        (enc1: Encoder<'T1>)
-        (enc2: Encoder<'T2>)
-        (enc3: Encoder<'T3>)
-        (enc4: Encoder<'T4>)
-        (enc5: Encoder<'T5>)
-        (enc6: Encoder<'T6>)
-        (enc7: Encoder<'T7>)
-        (enc8: Encoder<'T8>)
-        (v1, v2, v3, v4, v5, v6, v7, v8)
-        : IEncodable
-        =
-        array
-            [|
-                enc1 v1
-                enc2 v2
-                enc3 v3
-                enc4 v4
-                enc5 v5
-                enc6 v6
-                enc7 v7
-                enc8 v8
-            |]
-
-
-    let map
-        (keyEncoder: Encoder<'key>)
-        (valueEncoder: Encoder<'value>)
-        (values: Map<'key, 'value>)
-        : IEncodable
-        =
-        values
-        |> Map.toList
-        |> List.map (tuple2 keyEncoder valueEncoder)
-        |> list
-
-    ////////////
-    /// Enum ///
-    ///////////
-
-    module Enum =
-
-        let byte<'TEnum when 'TEnum: enum<byte>> (value: 'TEnum) : IEncodable =
-            LanguagePrimitives.EnumToValue value |> byte
-
-        let sbyte<'TEnum when 'TEnum: enum<sbyte>>
-            (value: 'TEnum)
-            : IEncodable
-            =
-            LanguagePrimitives.EnumToValue value |> sbyte
-
-        let int16<'TEnum when 'TEnum: enum<int16>>
-            (value: 'TEnum)
-            : IEncodable
-            =
-            LanguagePrimitives.EnumToValue value |> int16
-
-        let uint16<'TEnum when 'TEnum: enum<uint16>>
-            (value: 'TEnum)
-            : IEncodable
-            =
-            LanguagePrimitives.EnumToValue value |> uint16
-
-        let int<'TEnum when 'TEnum: enum<int>> (value: 'TEnum) : IEncodable =
-            LanguagePrimitives.EnumToValue value |> int
-
-        let uint32<'TEnum when 'TEnum: enum<uint32>>
-            (value: 'TEnum)
-            : IEncodable
-            =
-            LanguagePrimitives.EnumToValue value |> uint32
-
-    let option (encoder: Encoder<'a>) =
-        Option.map encoder >> Option.defaultWith (fun _ -> nil)
-
-    let inline toJsonValue
-        (helpers: IEncoderHelpers<'JsonValue>)
-        (json: IEncodable)
-        =
-        json.Encode(helpers)

package/fable_modules/Thoth.Json.Core.0.4.0/Encode.fs.js

@@ -1,192 +0,0 @@
-import { map as map_1 } from "../fable-library-js.4.24.0/List.js";
-import { map as map_2 } from "../fable-library-js.4.24.0/Seq.js";
-import { disposeSafe, getEnumerator } from "../fable-library-js.4.24.0/Util.js";
-import { toList, toSeq } from "../fable-library-js.4.24.0/Map.js";
-import { map as map_3 } from "../fable-library-js.4.24.0/Array.js";
-import { map as map_4, defaultArgWith } from "../fable-library-js.4.24.0/Option.js";
-
-export function float32(value) {
-    return {
-        Encode(helpers) {
-            return helpers.encodeDecimalNumber(value);
-        },
-    };
-}
-
-export function list(values) {
-    return {
-        Encode(helpers) {
-            const arg = map_1((v) => v.Encode(helpers), values);
-            return helpers.encodeList(arg);
-        },
-    };
-}
-
-export function seq(values) {
-    return {
-        Encode(helpers) {
-            const arg = map_2((v) => v.Encode(helpers), values);
-            return helpers.encodeSeq(arg);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export function tuple2(enc1, enc2, v1, v2) {
-    const values = [enc1(v1), enc2(v2)];
-    return {
-        Encode(helpers) {
-            const arg = map_3((v) => v.Encode(helpers), values);
-            return helpers.encodeArray(arg);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export 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);
-        },
-    };
-}
-
-export function map(keyEncoder, valueEncoder, values) {
-    return list(map_1((tupledArg) => tuple2(keyEncoder, valueEncoder, tupledArg[0], tupledArg[1]), toList(values)));
-}
-
-export function Enum_byte(value) {
-    return {
-        Encode(helpers) {
-            return helpers.encodeUnsignedIntegralNumber(value);
-        },
-    };
-}
-
-export function Enum_sbyte(value) {
-    return {
-        Encode(helpers) {
-            return helpers.encodeSignedIntegralNumber(value);
-        },
-    };
-}
-
-export function Enum_int16(value) {
-    return {
-        Encode(helpers) {
-            return helpers.encodeSignedIntegralNumber(value);
-        },
-    };
-}
-
-export function Enum_uint16(value) {
-    return {
-        Encode(helpers) {
-            return helpers.encodeUnsignedIntegralNumber(value);
-        },
-    };
-}
-
-export function Enum_int(value) {
-    return {
-        Encode(helpers) {
-            return helpers.encodeSignedIntegralNumber(value);
-        },
-    };
-}
-
-export function Enum_uint32(value) {
-    return {
-        Encode(helpers) {
-            return helpers.encodeUnsignedIntegralNumber(value);
-        },
-    };
-}
-
-export function option(encoder) {
-    return (arg) => defaultArgWith(map_4(encoder, arg), () => ({
-        Encode(helpers) {
-            return helpers.encodeNull();
-        },
-    }));
-}
-

package/fable_modules/Thoth.Json.Core.0.4.0/Thoth.Json.Core.fableproj

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
-    <PropertyGroup>
-        <Description>
-Elm-inspired encoder and decoder for JSON, this package is the core library which can be used on any F# project.
-
-Pick the right additional package for your runtime:
-
-- Thoth.Json.JavaScript
-- Thoth.Json.Python
-- Thoth.Json.Newtonsoft
-        </Description>
-        <FablePackageType>library</FablePackageType>
-        <PackageTags>fable-all;fsharp;json</PackageTags>
-    </PropertyGroup>
-    <PropertyGroup>
-        <TargetFramework>netstandard2.0</TargetFramework>
-    </PropertyGroup>
-    <ItemGroup>
-        <Compile Include="Types.fs" />
-        <Compile Include="Decode.fs" />
-        <Compile Include="Encode.fs" />
-        <!-- <Compile Include="Extra.fs" /> -->
-    </ItemGroup>
-    <ItemGroup>
-        <PackageReference Include="EasyBuild.PackageReleaseNotes.Tasks">
-          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-          <PrivateAssets>all</PrivateAssets>
-        </PackageReference>
-        <PackageReference Include="Fable.Core" />
-        <PackageReference Include="Fable.Package.SDK" />
-    </ItemGroup>
-</Project>

package/fable_modules/Thoth.Json.Core.0.4.0/Types.fs

@@ -1,83 +0,0 @@
-namespace Thoth.Json.Core
-
-type IDecoderHelpers<'JsonValue> =
-    abstract isString: 'JsonValue -> bool
-    abstract isNumber: 'JsonValue -> bool
-    abstract isBoolean: 'JsonValue -> bool
-    abstract isNullValue: 'JsonValue -> bool
-    abstract isArray: 'JsonValue -> bool
-    abstract isObject: 'JsonValue -> bool
-    abstract hasProperty: string -> 'JsonValue -> bool
-    abstract isIntegralValue: 'JsonValue -> bool
-    abstract asString: 'JsonValue -> string
-    abstract asFloat: 'JsonValue -> float
-    abstract asFloat32: 'JsonValue -> float32
-    abstract asInt: 'JsonValue -> int
-    abstract asBoolean: 'JsonValue -> bool
-    abstract asArray: 'JsonValue -> 'JsonValue[]
-    abstract getProperty: string * 'JsonValue -> 'JsonValue
-    abstract getProperties: 'JsonValue -> string seq
-    abstract anyToString: 'JsonValue -> string
-
-type IEncoderHelpers<'JsonValue> =
-    abstract encodeString: string -> 'JsonValue
-    abstract encodeChar: char -> 'JsonValue
-    abstract encodeDecimalNumber: float -> 'JsonValue
-    abstract encodeBool: bool -> 'JsonValue
-    abstract encodeNull: unit -> 'JsonValue
-    abstract encodeObject: (string * 'JsonValue) seq -> 'JsonValue
-    abstract encodeArray: 'JsonValue array -> 'JsonValue
-    abstract encodeList: 'JsonValue list -> 'JsonValue
-    abstract encodeSeq: 'JsonValue seq -> 'JsonValue
-    abstract encodeResizeArray: ResizeArray<'JsonValue> -> 'JsonValue
-    // See https://github.com/thoth-org/Thoth.Json/issues/187 for more information
-    // about why we make a distinction between signed and unsigned integral numbers
-    // when encoding them.
-    abstract encodeSignedIntegralNumber: int32 -> 'JsonValue
-    abstract encodeUnsignedIntegralNumber: uint32 -> 'JsonValue
-
-type ErrorReason<'JsonValue> =
-    | BadPrimitive of string * 'JsonValue
-    | BadPrimitiveExtra of string * 'JsonValue * string
-    | BadType of string * 'JsonValue
-    | BadField of string * 'JsonValue
-    | BadPath of string * 'JsonValue * string
-    | TooSmallArray of string * 'JsonValue
-    | FailMessage of string
-    | BadOneOf of DecoderError<'JsonValue> list
-
-and DecoderError<'JsonValue> = string * ErrorReason<'JsonValue>
-
-type Decoder<'T> =
-    abstract member Decode<'JsonValue> :
-        helpers: IDecoderHelpers<'JsonValue> * value: 'JsonValue ->
-            Result<'T, DecoderError<'JsonValue>>
-
-/// <summary>
-/// A JSON value
-/// </summary>
-/// <remarks>
-/// Some types don't have a direct representation in this DU,
-/// this to make sure we represent them in the same way between the different
-/// backends.
-///
-/// For example, <c>decimal</c> use <c>string</c> as the underlying type.
-/// </remarks>
-[<RequireQualifiedAccess; NoComparison>]
-type Json =
-    | String of string
-    | Char of char
-    | DecimalNumber of float
-    | Null
-    | Boolean of bool
-    | Object of (string * Json) seq
-    | Array of Json[]
-    // Thoth.Json as an abritrary limit to the size of numbers
-    | IntegralNumber of uint32
-    | Unit
-
-type IEncodable =
-    abstract member Encode<'JsonValue> :
-        helpers: IEncoderHelpers<'JsonValue> -> 'JsonValue
-
-type Encoder<'T> = 'T -> IEncodable

package/fable_modules/Thoth.Json.Core.0.4.0/Types.fs.js

@@ -1,33 +0,0 @@
-import { Union } from "../fable-library-js.4.24.0/Types.js";
-import { uint32_type, array_type, class_type, bool_type, float64_type, char_type, union_type, list_type, tuple_type, string_type } from "../fable-library-js.4.24.0/Reflection.js";
-
-export 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 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)))]]]);
-}
-
-export 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"];
-    }
-}
-
-export 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]], []]);
-}
-