starlight-fsharp-oracle 0.1.0 → 0.1.2

package/dist/fable_modules/Thoth.Json.Core.0.9.0/DecoderCE.fs

@@ -0,0 +1,106 @@
+namespace Thoth.Json.Core
+
+[<AutoOpen>]
+module DecoderCE =
+
+    type DecoderBuilder internal () =
+        member inline _.Bind(m, f) = Decode.andThen f m
+
+        member _.BindReturn(m, f) = Decode.map f m
+
+        member _.Bind2Return(d1, d2, ctor: struct ('a * 'b) -> 't) =
+            Decode.map2 (fun a b -> ctor struct (a, b)) d1 d2
+
+        member _.Bind3Return(d1, d2, d3, ctor: struct ('a * 'b * 'c) -> 't) =
+            Decode.map3 (fun a b c -> ctor struct (a, b, c)) d1 d2 d3
+
+        member _.Bind4Return
+            (d1, d2, d3, d4, ctor: struct ('a * 'b * 'c * 'd) -> 't)
+            =
+            Decode.map4 (fun a b c d -> ctor struct (a, b, c, d)) d1 d2 d3 d4
+
+        member _.Bind5Return
+            (d1, d2, d3, d4, d5, ctor: struct ('a * 'b * 'c * 'd * 'e) -> 't)
+            =
+            Decode.map5
+                (fun a b c d e -> ctor struct (a, b, c, d, e))
+                d1
+                d2
+                d3
+                d4
+                d5
+
+        member _.Bind6Return
+            (
+                d1,
+                d2,
+                d3,
+                d4,
+                d5,
+                d6,
+                ctor: struct ('a * 'b * 'c * 'd * 'e * 'f) -> 't
+            )
+            =
+            Decode.map6
+                (fun a b c d e f -> ctor struct (a, b, c, d, e, f))
+                d1
+                d2
+                d3
+                d4
+                d5
+                d6
+
+        member _.Bind7Return
+            (
+                d1,
+                d2,
+                d3,
+                d4,
+                d5,
+                d6,
+                d7,
+                ctor: struct ('a * 'b * 'c * 'd * 'e * 'f * 'g) -> 't
+            )
+            =
+            Decode.map7
+                (fun a b c d e f g -> ctor struct (a, b, c, d, e, f, g))
+                d1
+                d2
+                d3
+                d4
+                d5
+                d6
+                d7
+
+        member _.Bind8Return
+            (
+                d1,
+                d2,
+                d3,
+                d4,
+                d5,
+                d6,
+                d7,
+                d8,
+                ctor: struct ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h) -> 't
+            )
+            =
+            Decode.map8
+                (fun a b c d e f g h -> ctor struct (a, b, c, d, e, f, g, h))
+                d1
+                d2
+                d3
+                d4
+                d5
+                d6
+                d7
+                d8
+
+        member _.MergeSources(d1, d2) =
+            Decode.map2 (fun a b -> struct (a, b)) d1 d2
+
+        member _.Return(x) = Decode.succeed x
+
+        member _.ReturnFrom(x: Decoder<'a>) = x
+
+    let decoder = DecoderBuilder()

package/dist/fable_modules/Thoth.Json.Core.0.9.0/DecoderCE.fs.js

@@ -0,0 +1,63 @@
+
+import { class_type } from "../fable-library-js.5.0.0-rc.7/Reflection.js";
+import { succeed, map8, map7, map6, map5, map4, map3, map2, map } from "./Decode.fs.js";
+
+export class DecoderBuilder {
+    constructor() {
+    }
+}
+
+export function DecoderBuilder_$reflection() {
+    return class_type("Thoth.Json.Core.DecoderCE.DecoderBuilder", undefined, DecoderBuilder);
+}
+
+export function DecoderBuilder_$ctor() {
+    return new DecoderBuilder();
+}
+
+export function DecoderBuilder__BindReturn_6BCFE77E(_, m, f) {
+    return map(f, m);
+}
+
+export function DecoderBuilder__Bind2Return_Z12312F75(_, d1, d2, ctor) {
+    return map2((a, b) => ctor([a, b]), d1, d2);
+}
+
+export function DecoderBuilder__Bind3Return_B877D49(_, d1, d2, d3, ctor) {
+    return map3((a, b, c) => ctor([a, b, c]), d1, d2, d3);
+}
+
+export function DecoderBuilder__Bind4Return_Z70E81EB5(_, d1, d2, d3, d4, ctor) {
+    return map4((a, b, c, d) => ctor([a, b, c, d]), d1, d2, d3, d4);
+}
+
+export function DecoderBuilder__Bind5Return_1A977209(_, d1, d2, d3, d4, d5, ctor) {
+    return map5((a, b, c, d, e) => ctor([a, b, c, d, e]), d1, d2, d3, d4, d5);
+}
+
+export function DecoderBuilder__Bind6Return_Z1E2849F5(_, d1, d2, d3, d4, d5, d6, ctor) {
+    return map6((a, b, c, d, e, f) => ctor([a, b, c, d, e, f]), d1, d2, d3, d4, d5, d6);
+}
+
+export function DecoderBuilder__Bind7Return_Z16900C37(_, d1, d2, d3, d4, d5, d6, d7, ctor) {
+    return map7((a, b, c, d, e, f, g) => ctor([a, b, c, d, e, f, g]), d1, d2, d3, d4, d5, d6, d7);
+}
+
+export function DecoderBuilder__Bind8Return_512F4ECB(_, d1, d2, d3, d4, d5, d6, d7, d8, ctor) {
+    return map8((a, b, c, d, e, f, g, h) => ctor([a, b, c, d, e, f, g, h]), d1, d2, d3, d4, d5, d6, d7, d8);
+}
+
+export function DecoderBuilder__MergeSources_83ADF00(_, d1, d2) {
+    return map2((a, b) => [a, b], d1, d2);
+}
+
+export function DecoderBuilder__Return_1505(_, x) {
+    return succeed(x);
+}
+
+export function DecoderBuilder__ReturnFrom_1FBE35A8(_, x) {
+    return x;
+}
+
+export const decoder = DecoderBuilder_$ctor();
+

package/dist/fable_modules/Thoth.Json.Core.0.9.0/Encode.fs

@@ -0,0 +1,380 @@
+namespace Thoth.Json.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
+
+    let lazily<'t> (enc: Lazy<Encoder<'t>>) : Encoder<'t> =
+        fun (x: 't) -> enc.Value x
+
+    ////////////
+    /// 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
+
+    /// <summary>
+    /// Encodes an option value using the provided encoder.
+    ///
+    /// Attention, this encoder is lossy, it's result will not be able to distinguish between `'T option` and `'T option option`.
+    ///
+    /// If you need to distinguish between `'T option` and `'T option option`, use `losslessOption`.
+    /// </summary>
+    /// <param name="encoder">The encoder to apply if the value is Some</param>
+    /// <typeparam name="'a">The type of the value to encode</typeparam>
+    /// <returns>
+    /// The result of the encoder if the value is Some, otherwise nil
+    /// </returns>
+    let lossyOption (encoder: Encoder<'a>) =
+        Option.map encoder >> Option.defaultWith (fun _ -> nil)
+
+    /// <summary>
+    /// Encodes an option value using the provided encoder.
+    ///
+    /// This encoder is lossless, it's result will be able to distinguish between `'T option` and `'T option option`.
+    ///
+    /// If you don't need to distinguish between `'T option` and `'T option option`, use `lossyOption`.
+    /// </summary>
+    /// <param name="encoder">The encoder to apply if the value is Some</param>
+    /// <typeparam name="'a">The type of the value to encode</typeparam>
+    /// <returns>
+    /// If the value is Some, the object will have the following fields:
+    ///
+    /// - `$type` field set to `option`
+    /// - `$case` field set to `some`
+    /// - `$value` field set to the result of the encoder.
+    ///
+    /// If the value is None, the object will have the following fields:
+    ///
+    /// - `$type` field set to `option`
+    /// - `$case` field set to `none`
+    /// </returns>
+    let losslessOption (encoder: Encoder<'a>) (value: 'a option) =
+        match value with
+        | Some v ->
+            object
+                [
+                    "$type", string "option"
+                    "$case", string "some"
+                    "$value", encoder v
+                ]
+        | None ->
+            object
+                [
+                    "$type", string "option"
+                    "$case", string "none"
+                ]
+
+    let rec value: Encoder<Json> =
+        fun json ->
+            match json with
+            | Json.Null -> nil
+            | Json.Boolean b -> bool b
+            | Json.String s -> string s
+            | Json.Number f -> float f
+            | Json.Array xs -> list (List.map value xs)
+            | Json.Object kvps ->
+                kvps |> Seq.map (fun (k, v) -> k, value v) |> object
+
+    let inline toJsonValue
+        (helpers: IEncoderHelpers<'JsonValue>)
+        (json: IEncodable)
+        =
+        json.Encode(helpers)