starlight-fsharp-oracle 0.1.0 → 0.1.2

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

@@ -0,0 +1,289 @@
+
+import { map as map_1 } from "../fable-library-js.5.0.0-rc.7/List.js";
+import { map as map_2 } from "../fable-library-js.5.0.0-rc.7/Seq.js";
+import { disposeSafe, getEnumerator } from "../fable-library-js.5.0.0-rc.7/Util.js";
+import { toList, toSeq } from "../fable-library-js.5.0.0-rc.7/Map.js";
+import { map as map_3 } from "../fable-library-js.5.0.0-rc.7/Array.js";
+import { value as value_6, map as map_4, defaultArgWith } from "../fable-library-js.5.0.0-rc.7/Option.js";
+
+export function float32(value_1) {
+    return {
+        Encode(helpers) {
+            return helpers.encodeDecimalNumber(value_1);
+        },
+    };
+}
+
+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 lazily(enc, x) {
+    return enc.Value(x);
+}
+
+export function Enum_byte(value_1) {
+    return {
+        Encode(helpers) {
+            return helpers.encodeUnsignedIntegralNumber(value_1);
+        },
+    };
+}
+
+export function Enum_sbyte(value_1) {
+    return {
+        Encode(helpers) {
+            return helpers.encodeSignedIntegralNumber(value_1);
+        },
+    };
+}
+
+export function Enum_int16(value_1) {
+    return {
+        Encode(helpers) {
+            return helpers.encodeSignedIntegralNumber(value_1);
+        },
+    };
+}
+
+export function Enum_uint16(value_1) {
+    return {
+        Encode(helpers) {
+            return helpers.encodeUnsignedIntegralNumber(value_1);
+        },
+    };
+}
+
+export function Enum_int(value_1) {
+    return {
+        Encode(helpers) {
+            return helpers.encodeSignedIntegralNumber(value_1);
+        },
+    };
+}
+
+export function Enum_uint32(value_1) {
+    return {
+        Encode(helpers) {
+            return helpers.encodeUnsignedIntegralNumber(value_1);
+        },
+    };
+}
+
+/**
+ * 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`.
+ */
+export function lossyOption(encoder) {
+    return (arg) => defaultArgWith(map_4(encoder, arg), () => ({
+        Encode(helpers) {
+            return helpers.encodeNull();
+        },
+    }));
+}
+
+/**
+ * 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`.
+ */
+export 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_6(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 function value(json) {
+    switch (json.tag) {
+        case 3:
+            return {
+                Encode(helpers_1) {
+                    return helpers_1.encodeBool(json.fields[0]);
+                },
+            };
+        case 0:
+            return {
+                Encode(helpers_2) {
+                    return helpers_2.encodeString(json.fields[0]);
+                },
+            };
+        case 1:
+            return {
+                Encode(helpers_3) {
+                    return helpers_3.encodeDecimalNumber(json.fields[0]);
+                },
+            };
+        case 5:
+            return list(map_1(value, json.fields[0]));
+        case 4: {
+            const values = map_2((tupledArg) => [tupledArg[0], value(tupledArg[1])], json.fields[0]);
+            return {
+                Encode(helpers_4) {
+                    const arg = map_2((tupledArg_1) => [tupledArg_1[0], tupledArg_1[1].Encode(helpers_4)], values);
+                    return helpers_4.encodeObject(arg);
+                },
+            };
+        }
+        default:
+            return {
+                Encode(helpers) {
+                    return helpers.encodeNull();
+                },
+            };
+    }
+}
+

package/dist/fable_modules/Thoth.Json.Core.0.9.0/Thoth.Json.Core.fableproj

@@ -0,0 +1,37 @@
+<?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
+- Thoth.Json.System.Text.Json
+        </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" /> -->
+        <Compile Include="DecoderCE.fs" />
+    </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="EasyBuild.PackageReleaseNotes.Tasks">
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+          <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="Fable.Package.SDK">
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+          <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
+</Project>

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

@@ -0,0 +1,76 @@
+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>
+/// Although theoretically numbers are arbitrary prevision in JSON,
+/// here they are representated as `float`, which is in line with most implementations.
+/// </remarks>
+[<RequireQualifiedAccess; NoComparison>]
+type Json =
+    | String of string
+    | Number of float
+    | Null
+    | Boolean of bool
+    | Object of (string * Json) list
+    | Array of Json list
+
+type IEncodable =
+    abstract member Encode<'JsonValue> :
+        helpers: IEncoderHelpers<'JsonValue> -> 'JsonValue
+
+type Encoder<'T> = 'T -> IEncodable

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

@@ -0,0 +1,37 @@
+
+import { Union } from "../fable-library-js.5.0.0-rc.7/Types.js";
+import { bool_type, float64_type, union_type, list_type, tuple_type, string_type } from "../fable-library-js.5.0.0-rc.7/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)))]]]);
+}
+
+/**
+ * A JSON value
+ */
+export class Json extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["String", "Number", "Null", "Boolean", "Object", "Array"];
+    }
+}
+
+export function Json_$reflection() {
+    return union_type("Thoth.Json.Core.Json", [], Json, () => [[["Item", string_type]], [["Item", float64_type]], [], [["Item", bool_type]], [["Item", list_type(tuple_type(string_type, Json_$reflection()))]], [["Item", list_type(Json_$reflection())]]]);
+}
+

package/dist/fable_modules/Thoth.Json.Core.Auto.0.1.0/Casing.fs

@@ -0,0 +1,113 @@
+module Thoth.Json.Core.Auto.Casing
+
+open System
+open System.Text
+
+let private upperFirst (str: string) =
+    str.[..0].ToUpperInvariant() + str.[1..]
+
+/// Well-known two-letter acronyms that should remain all-caps in .NET naming conventions.
+/// Per Microsoft's guidelines, common acronyms like ID and IP should be kept uppercase
+/// (e.g., UserID instead of UserId, CustomerIP instead of CustomerIp).
+/// This matches how .NET Framework types are named (IPAddress, IDisposable, etc.).
+let private dotNetAcronyms =
+    Set.ofSeq
+        [
+            "id"
+            "ip"
+        ]
+
+let convertCase (source: CaseStrategy) (dest: CaseStrategy) (text: string) =
+    if source = dest then
+        text
+    else
+        let words =
+            match source with
+            | SnakeCase
+            | ScreamingSnakeCase ->
+                text.Split([| '_' |], StringSplitOptions.RemoveEmptyEntries)
+                |> Seq.toList
+            | PascalCase
+            | CamelCase
+            | DotNetPascalCase
+            | DotNetCamelCase ->
+                seq {
+                    let sb = StringBuilder()
+
+                    for c in text do
+                        if Char.IsUpper c && sb.Length > 0 then
+                            sb.ToString()
+                            sb.Clear() |> ignore
+
+                        sb.Append(c) |> ignore
+
+                    if sb.Length > 0 then
+                        sb.ToString()
+                }
+                |> Seq.fold
+                    (fun state next ->
+                        if next.Length > 1 then
+                            next :: state
+                        else
+                            match state with
+                            | [] -> [ next ]
+                            | x :: xs ->
+                                if
+                                    x.Length = 1
+                                    || x |> Seq.forall Char.IsUpper
+                                then
+                                    (x + next) :: xs
+                                else
+                                    next :: x :: xs
+                    )
+                    []
+                |> Seq.rev
+                |> Seq.toList
+
+        match dest with
+        | ScreamingSnakeCase ->
+            words
+            |> Seq.map (fun x -> x.ToUpperInvariant())
+            |> String.concat "_"
+        | SnakeCase ->
+            words
+            |> Seq.map (fun x -> x.ToLowerInvariant())
+            |> String.concat "_"
+        | PascalCase ->
+            words
+            |> Seq.map (fun x -> x.ToLowerInvariant() |> upperFirst)
+            |> String.concat ""
+        | CamelCase ->
+            words
+            |> Seq.mapi (fun i x ->
+                if i = 0 then
+                    x.ToLowerInvariant()
+                else
+                    x.ToLowerInvariant() |> upperFirst
+            )
+            |> String.concat ""
+        | DotNetPascalCase ->
+            words
+            |> Seq.map (fun x ->
+                let u = x.ToLowerInvariant()
+
+                if Set.contains u dotNetAcronyms then
+                    u.ToUpperInvariant()
+                else
+                    upperFirst u
+            )
+            |> String.concat ""
+        | DotNetCamelCase ->
+            words
+            |> Seq.mapi (fun i x ->
+                if i = 0 then
+                    x.ToLowerInvariant()
+                else
+                    let u = x.ToLowerInvariant()
+
+                    if Set.contains u dotNetAcronyms then
+                        u.ToUpperInvariant()
+                    else
+                        upperFirst u
+            )
+            |> String.concat ""