@nfdi4plants/arctrl 1.0.0-alpha10

package/fable_modules/Fable.Promise.3.2.0/Promise.fs.js

@@ -0,0 +1,217 @@
+import { Result_MapError, Result_Map, FSharpResult$2 } from "../fable-library.4.1.4/Choice.js";
+import { class_type } from "../fable-library.4.1.4/Reflection.js";
+import { disposeSafe, getEnumerator } from "../fable-library.4.1.4/Util.js";
+
+/**
+ * This is an identity function, it calls the given function and return the promise value untouched.
+ * <example>
+ * <code lang="fsharp">
+ * fetchUser ()
+ * |> Promise.tap (fun user ->
+ * // Do something
+ * console.log "The user has been received"
+ * )
+ * |> Promise.map (fun user ->
+ * // user value is available here untouched
+ * )
+ * </code>
+ * </example>
+ */
+export function tap(fn, a) {
+    return a.then((x) => {
+        fn(x);
+        return x;
+    });
+}
+
+/**
+ * Map the <c>Promise</c> result into a <c>Result</c> type.
+ * <example>
+ * <code lang="fsharp">
+ * Success example
+ * Promise.lift 42
+ * |> Promise.result
+ * |> Promise.map (fun value ->
+ * // value = Ok 42
+ * )
+ * 
+ * // Fail example
+ * Promise.reject "Invalid value"
+ * |> Promise.result
+ * |> Promise.map (fun value ->
+ * // value = Error "Invalid value"
+ * )
+ * </code>
+ * </example>
+ */
+export function result(a) {
+    return a.then((arg) => (new FSharpResult$2(0, [arg]))).catch((arg_1) => (new FSharpResult$2(1, [arg_1])));
+}
+
+/**
+ * Evaluates to `myPromise |> Promise.map (Result.map fn)`
+ * <example>
+ * <code lang="fsharp">
+ * Promise.lift 42
+ * |> Promise.result
+ * |> Promise.mapResult (fun value ->
+ * value + 10
+ * )
+ * |> Promise.map (fun value ->
+ * // value = Ok 52
+ * )
+ * </code>
+ * </example>
+ */
+export function mapResult(fn, a) {
+    return a.then((result_1) => Result_Map(fn, result_1));
+}
+
+/**
+ * Transform the success part of a result promise into another promise.
+ * <example>
+ * <code lang="fsharp">
+ * let multiplyBy2 (value : int) =
+ * Promise.create (fun resolve reject ->
+ * resolve (value * 2)
+ * )
+ * 
+ * Promise.lift 42
+ * |> Promise.result
+ * |> Promise.bindResult (fun value ->
+ * multiplyBy2 value
+ * )
+ * |> Promise.map (fun value ->
+ * // value = Ok 84
+ * )
+ * </code>
+ * </example>
+ */
+export function bindResult(fn, a) {
+    return a.then((a_1) => {
+        if (a_1.tag === 1) {
+            return Promise.resolve(new FSharpResult$2(1, [a_1.fields[0]]));
+        }
+        else {
+            const pr = fn(a_1.fields[0]);
+            return pr.then((arg) => (new FSharpResult$2(0, [arg])));
+        }
+    });
+}
+
+/**
+ * Evaluates to <c>myPromise |> Promise.map (Result.map fn)</c>
+ * <example>
+ * <code lang="fsharp">
+ * Promise.reject -1
+ * |> Promise.result
+ * |> Promise.mapResultError (fun value ->
+ * $"%s{value} is not a valid value"
+ * )
+ * |> Promise.map (fun value ->
+ * // value = Error "-1 is not a valid value"
+ * )
+ * </code>
+ * </example>
+ */
+export function mapResultError(fn, a) {
+    return a.then((result_1) => Result_MapError(fn, result_1));
+}
+
+export class PromiseBuilder {
+    constructor() {
+    }
+}
+
+export function PromiseBuilder_$reflection() {
+    return class_type("Promise.PromiseBuilder", void 0, PromiseBuilder);
+}
+
+export function PromiseBuilder_$ctor() {
+    return new PromiseBuilder();
+}
+
+export function PromiseBuilder__For_1565554B(_, seq, body) {
+    let pr;
+    let p = Promise.resolve(void 0);
+    const enumerator = getEnumerator(seq);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const a = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            p = ((pr = p, pr.then(() => body(a))));
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return p;
+}
+
+export function PromiseBuilder__While_2044D34(this$, guard, p) {
+    if (guard()) {
+        return p.then(() => PromiseBuilder__While_2044D34(this$, guard, p));
+    }
+    else {
+        return Promise.resolve(void 0);
+    }
+}
+
+export function PromiseBuilder__TryFinally_7D49A2FD(_, p, compensation) {
+    return p.then((x) => {
+        compensation();
+        return x;
+    }).catch((er) => {
+        compensation();
+        throw er;
+    });
+}
+
+export function PromiseBuilder__Delay_62FBFDE1(_, generator) {
+    return {
+        then: (onSuccess, onError) => {
+            try {
+                return generator().then(onSuccess, onError);
+            }
+            catch (er) {
+                if (onError == null) {
+                    return Promise.reject(er);
+                }
+                else {
+                    try {
+                        const a = onError(er);
+                        return Promise.resolve(a);
+                    }
+                    catch (er_1) {
+                        return Promise.reject(er_1);
+                    }
+                }
+            }
+        },
+        catch: (onError_1) => {
+            try {
+                return generator().catch(onError_1);
+            }
+            catch (er_2) {
+                try {
+                    const a_1 = onError_1(er_2);
+                    return Promise.resolve(a_1);
+                }
+                catch (er_3) {
+                    return Promise.reject(er_3);
+                }
+            }
+        },
+    };
+}
+
+export function PromiseBuilder__Run_212F1D4B(_, p) {
+    return p.then((x) => x);
+}
+
+export function PromiseBuilder__Using_74F7E79D(this$, resource, binder) {
+    return PromiseBuilder__TryFinally_7D49A2FD(this$, binder(resource), () => {
+        let copyOfStruct = resource;
+        disposeSafe(copyOfStruct);
+    });
+}
+

package/fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs

@@ -0,0 +1,31 @@
+[<AutoOpen>]
+module PromiseImpl
+
+let promise = Promise.PromiseBuilder()
+
+[<RequireQualifiedAccess>]
+module SettledValue =
+
+    /// <summary>
+    /// Helper functionm to convert a settled result into an F# result
+    /// </summary>
+    /// <param name="p">The settled result</param>
+    /// <typeparam name="'T"></typeparam>
+    /// <returns>The F# result</returns>
+    /// <example>
+    /// <code lang="fsharp">
+    /// Promise.allSettled [success; rejection]
+    /// |> Promise.iter (fun results ->
+    ///     for result in results do 
+    ///       match SettledValue.toResult result  with 
+    ///       | Ok value ->
+    ///         printfn "Success: %A" value
+    ///       | Error err -> 
+    ///         eprintfn "Error: %O" err
+    /// )
+    /// </code>
+    /// </example>
+    let toResult (p: Promise.SettledValue<'T>) =
+        match p.status with 
+        | Promise.Fulfilled -> Ok p.value.Value
+        | Promise.Rejected -> Error p.reason.Value

package/fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs.js

@@ -0,0 +1,19 @@
+import { PromiseBuilder_$ctor } from "./Promise.fs.js";
+import { value } from "../fable-library.4.1.4/Option.js";
+import { FSharpResult$2 } from "../fable-library.4.1.4/Choice.js";
+
+export const promise = PromiseBuilder_$ctor();
+
+/**
+ * Helper functionm to convert a settled result into an F# result
+ */
+export function SettledValue_toResult(p) {
+    const matchValue = p.status;
+    if (matchValue === "rejected") {
+        return new FSharpResult$2(1, [value(p.reason)]);
+    }
+    else {
+        return new FSharpResult$2(0, [value(p.value)]);
+    }
+}
+

package/fable_modules/Fable.SimpleHttp.3.5.0/Fable.SimpleHttp.fableproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <Description>A library for easily making Http requests in Fable projects.</Description>
+        <PackageProjectUrl>https://github.com/Zaid-Ajaj/Fable.SimpleHttp</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/Zaid-Ajaj/Fable.SimpleHttp.git</RepositoryUrl>
+        <PackageLicenseUrl>https://github.com/Zaid-Ajaj/Fable.SimpleHttp/blob/master/LICENSE</PackageLicenseUrl>
+        <PackageIconUrl></PackageIconUrl>
+        <PackageTags>fsharp;fable;http</PackageTags>
+        <Authors>Zaid Ajaj</Authors>
+        <Version>3.5.0</Version>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <PackageReleaseNotes>Removing prerelease flag from Fable.Core dependency</PackageReleaseNotes>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="Types.fs" />
+        <Compile Include="Http.fs" />
+    </ItemGroup>
+    <ItemGroup>
+        <Content Include="*.fsproj; *.fs;" Exclude="**\*.fs.js" PackagePath="fable\" />
+    </ItemGroup>
+    <Import Project="..\.paket\Paket.Restore.targets" />
+</Project>

package/fable_modules/Fable.SimpleHttp.3.5.0/Http.fs

@@ -0,0 +1,357 @@
+namespace Fable.SimpleHttp
+
+open System
+open Browser
+open Browser.Types
+open Fable.Core
+
+#if !FABLE_COMPILER
+open System.Net.Http
+#endif
+
+module Blob =
+    /// Creates a Blob from the given input string
+    [<Emit("new Blob([$0], { 'type':'text/plain' })")>]
+    let fromText (value: string) : Blob = jsNative
+
+    [<Emit("window.URL.createObjectURL($0)")>]
+    let createObjectURL (blob: Blob) : string = jsNative
+
+    /// Download a Blob
+    let download (blob: Blob) (fileName: string) =
+        let element = unbox<HTMLAnchorElement> (document.createElement "a")
+        element.target <- "_blank"
+        element.href <- createObjectURL(blob)
+        element.setAttribute("download", fileName)
+        document.body.appendChild(element) |> ignore
+        element.click()
+        document.body.removeChild(element) |> ignore
+
+module File =
+    /// Creates a File from the given input string and file name
+    [<Emit("new File([$0], $1, { 'type':'text/plain' })")>]
+    let fromText (value: string) (fileName: string) : File = jsNative
+
+
+/// Utility functions to work with blob and file APIs.
+module FileReader =
+    /// Asynchronously reads the blob data content as string
+    let readBlobAsText (blob: Blob) : Async<string> =
+        Async.FromContinuations <| fun (resolve, _, _) ->
+            let reader = FileReader.Create()
+            reader.onload <- fun _ ->
+                if reader.readyState = FileReaderState.DONE
+                then resolve (unbox reader.result)
+
+            reader.readAsText(blob)
+
+    /// Asynchronously reads the blob data content as string
+    let readFileAsText (file: File) : Async<string> =
+        Async.FromContinuations <| fun (resolve, _, _) ->
+            let reader = FileReader.Create()
+            reader.onload <- fun _ ->
+                if reader.readyState = FileReaderState.DONE
+                then resolve (unbox reader.result)
+
+            reader.readAsText(file)
+
+module FormData =
+
+    /// Creates a new FormData object
+    [<Emit("new FormData()")>]
+    let create() : FormData = jsNative
+
+    /// Appends a key-value pair to the form data
+    let append (key:string) (value:string) (form : FormData) : FormData =
+        form.append(key, value)
+        form
+
+    /// Appends a file to the form data
+    let appendFile (key: string) (file: File) (form: FormData) : FormData =
+        form.append (key, file)
+        form
+
+    /// Appends a named file to the form data
+    let appendNamedFile (key: string) (fileName: string) (file: File) (form: FormData) : FormData =
+        form.append (key, file, fileName)
+        form
+
+    /// Appends a blog to the form data
+    let appendBlob (key: string) (blob: Blob) (form: FormData) : FormData =
+        form.append (key, blob)
+        form
+
+    /// Appends a blog to the form data
+    let appendNamedBlob (key: string) (fileName: string) (blob: Blob) (form: FormData) : FormData =
+        form.append (key, blob, fileName)
+        form
+
+module Headers =
+    let contentType value = Header("Content-Type", value)
+    let accept value = Header("Accept", value)
+    let acceptCharset value = Header("Accept-Charset", value)
+    let acceptEncoding value = Header("Accept-Encoding", value)
+    let acceptLanguage value = Header("Accept-Language", value)
+    let acceptDateTime value = Header("Accept-Datetime", value)
+    let authorization value = Header("Authorization", value)
+    let cacheControl value = Header("Cache-Control", value)
+    let connection value = Header("Connection", value)
+    let cookie value = Header("Cookie", value)
+    let contentMD5 value = Header("Content-MD5", value)
+    let date value = Header("Date", value)
+    let expect value = Header("Expect", value)
+    let ifMatch value = Header("If-Match", value)
+    let ifModifiedSince value = Header("If-Modified-Since", value)
+    let ifNoneMatch value = Header("If-None-Match", value)
+    let ifRange value = Header("If-Range", value)
+    let IfUnmodifiedSince value = Header("If-Unmodified-Since", value)
+    let maxForwards value = Header("Max-Forwards", value)
+    let origin value = Header ("Origin", value)
+    let pragma value = Header("Pragma", value)
+    let proxyAuthorization value = Header("Proxy-Authorization", value)
+    let range value = Header("Range", value)
+    let referer value = Header("Referer", value)
+    let userAgent value = Header("User-Agent", value)
+    let create key value = Header(key, value)
+
+module Http =
+
+    let private defaultRequest =
+        { url = "";
+          method = HttpMethod.GET
+          headers = []
+          withCredentials = false
+          overridenMimeType = None
+          overridenResponseType = None
+          timeout = None
+          content = BodyContent.Empty }
+
+    let private emptyResponse =
+        { statusCode = 0
+          responseText = ""
+          responseType = ""
+          responseUrl = ""
+          responseHeaders = Map.empty
+          content = ResponseContent.Text "" }
+
+    let private splitAt (delimiter: string) (input: string) : string [] =
+        if String.IsNullOrEmpty input then [| input |]
+        else input.Split([| delimiter |], StringSplitOptions.None)
+
+    let private serializeMethod = function
+        | HttpMethod.GET -> "GET"
+        | HttpMethod.POST -> "POST"
+        | HttpMethod.PATCH -> "PATCH"
+        | HttpMethod.PUT -> "PUT"
+        | HttpMethod.DELETE -> "DELETE"
+        | HttpMethod.OPTIONS -> "OPTIONS"
+        | HttpMethod.HEAD -> "HEAD"
+
+    /// Starts the configuration of the request with the specified url
+    let request (url: string) : HttpRequest =
+        { defaultRequest with url = url }
+
+    /// Sets the Http method of the request
+    let method httpVerb (req: HttpRequest) =
+        { req with method = httpVerb }
+
+    /// Appends a header to the request configuration
+    let header (singleHeader: Header) (req: HttpRequest) =
+        { req with headers = List.append req.headers [singleHeader] }
+
+    /// Appends a list of headers to the request configuration
+    let headers (values: Header list) (req: HttpRequest)  =
+        { req with headers = List.append req.headers values }
+
+    /// Enables cross-site credentials such as cookies
+    let withCredentials (enabled: bool) (req: HttpRequest) =
+        { req with withCredentials = enabled }
+
+    /// Enables Http request timeout
+    let withTimeout (timeoutInMilliseconds: int) (req: HttpRequest) =
+        { req with timeout = Some timeoutInMilliseconds}
+
+    /// Specifies a MIME type other than the one provided by the server to be used instead when interpreting the data being transferred in a request. This may be used, for example, to force a stream to be treated and parsed as "text/xml", even if the server does not report it as such.
+    let overrideMimeType (value: string) (req: HttpRequest) =
+        { req with overridenMimeType = Some value }
+
+    /// Change the expected response type from the server
+    let overrideResponseType (value: ResponseTypes) (req: HttpRequest) =
+        { req with overridenResponseType = Some value }
+
+    /// Sets the body content of the request
+    let content (bodyContent: BodyContent) (req: HttpRequest) : HttpRequest =
+        { req with content = bodyContent }
+
+    /// Sends the request to the server, this function does not throw
+    let send (req: HttpRequest) : Async<HttpResponse> =
+#if FABLE_COMPILER
+        Async.FromContinuations <| fun (resolve, reject, _) ->
+            let xhr = XMLHttpRequest.Create()
+            xhr.``open``(serializeMethod req.method, req.url)
+            xhr.onreadystatechange <- fun _ ->
+                if xhr.readyState = ReadyState.Done
+                then resolve {
+                    responseText =
+                        match xhr.responseType with
+                        | "" -> xhr.responseText
+                        | "text" -> xhr.responseText
+                        | _ -> ""
+
+                    statusCode = int xhr.status
+                    responseType = xhr.responseType
+                    content =
+                        match xhr.responseType with
+                        | ("" | "text") -> ResponseContent.Text xhr.responseText
+                        | "arraybuffer" -> ResponseContent.ArrayBuffer (unbox xhr.response)
+                        | "blob" -> ResponseContent.Blob (unbox xhr.response)
+                        | _ -> ResponseContent.Unknown xhr.response
+
+                    responseHeaders =
+                        xhr.getAllResponseHeaders()
+                        |> splitAt "\r\n"
+                        |> Array.choose (fun headerLine ->
+                            let parts = splitAt ":" headerLine
+                            match List.ofArray parts with
+                            | key :: rest ->  Some (key.ToLower(), (String.concat ":" rest).Trim())
+                            | otherwise -> None)
+                        |> Map.ofArray
+
+                    responseUrl = xhr.responseURL
+                }
+
+            for (Header(key, value)) in req.headers do
+                xhr.setRequestHeader(key, value)
+
+            xhr.withCredentials <- req.withCredentials
+
+            match req.overridenMimeType with
+            | Some mimeType -> xhr.overrideMimeType(mimeType)
+            | None -> ()
+
+            match req.overridenResponseType with
+            | Some ResponseTypes.Text -> xhr.responseType <- "text"
+            | Some ResponseTypes.Blob -> xhr.responseType <- "blob"
+            | Some ResponseTypes.ArrayBuffer -> xhr.responseType <- "arraybuffer"
+            | None -> ()
+
+            match req.timeout with
+            | Some timeout -> xhr.timeout <- timeout
+            | None -> ()
+
+            match req.content with 
+            | BodyContent.Empty -> xhr.send()
+            | BodyContent.Text value -> xhr.send(value)
+            | BodyContent.Form formData -> xhr.send(formData)
+            | BodyContent.Binary blob -> xhr.send(blob)
+#else
+        async {
+            try
+                use requestMessage = new HttpRequestMessage()
+                requestMessage.RequestUri <- Uri(req.url)
+                requestMessage.Method <-
+                    match req.method with
+                    | HttpMethod.GET     -> HttpMethod.Get
+                    | HttpMethod.POST    -> HttpMethod.Post
+                    | HttpMethod.PUT     -> HttpMethod.Put
+                    | HttpMethod.PATCH   -> HttpMethod "PATCH"
+                    | HttpMethod.DELETE  -> HttpMethod.Delete
+                    | HttpMethod.HEAD    -> HttpMethod.Head
+                    | HttpMethod.OPTIONS -> HttpMethod.Options
+                req.headers
+                |> Seq.iter (fun (Header (key, value)) ->
+                    requestMessage.Headers.Add(key, value))
+                use content =
+                    match req.content with
+                    | BodyContent.Text text -> new StringContent(text)
+                    | BodyContent.Empty -> null
+                    | _ -> failwith "Only BodyContent.Text is supported in the dotnet implementation"
+                requestMessage.Content <- content
+
+                use client = new HttpClient()
+
+                match req.timeout with
+                | Some timeout -> client.Timeout <- TimeSpan.FromMilliseconds(timeout)
+                | None -> ()
+
+                let! response = client.SendAsync requestMessage |> Async.AwaitTask
+                let! responseBody = response.Content.ReadAsStringAsync() |> Async.AwaitTask
+
+                let headers =
+                    response.Headers
+                    |> Seq.choose (fun kv ->
+                        kv.Value
+                        |> Seq.tryLast
+                        |> Option.map (fun value -> kv.Key, value))
+                    |> Map.ofSeq
+
+                return
+                    { statusCode = int response.StatusCode
+                      responseText = responseBody
+                      responseType = "text"
+                      responseHeaders = headers
+                      responseUrl = req.url
+                      content = ResponseContent.Text responseBody }
+            with
+            // We're catching a lot here to mimic the behaviour of the JS
+            // implementation, which isn't able to expose the kind of error.
+            | :? ArgumentException ->
+                return emptyResponse // invalid uri
+            | :? HttpRequestException
+            | :? AggregateException as aggrEx when (aggrEx.InnerException :? HttpRequestException) ->
+                return emptyResponse // connection errors
+        }
+#endif
+
+    /// Safely sends a GET request and returns a tuple(status code * response text). This function does not throw.
+    let get url : Async<int * string> =
+        async {
+            let! response =
+                request url
+                |> method HttpMethod.GET
+                |> send
+            return response.statusCode, response.responseText
+        }
+
+    /// Safely sends a PUT request and returns a tuple(status code * response text). This function does not throw.
+    let put url (data: string) : Async<int * string> =
+        async {
+            let! response =
+                request url
+                |> method HttpMethod.PUT
+                |> content (BodyContent.Text data)
+                |> send
+            return response.statusCode, response.responseText
+        }
+
+    /// Safely sends a DELETE request and returns a tuple(status code * response text). This function does not throw.
+    let delete url : Async<int * string> =
+        async {
+            let! response =
+                request url
+                |> method HttpMethod.DELETE
+                |> send
+            return response.statusCode, response.responseText
+        }
+
+    /// Safely sends a PATCH request and returns a tuple(status code * response text). This function does not throw.
+    let patch url (data: string) : Async<int * string> =
+        async {
+            let! response =
+                request url
+                |> method HttpMethod.PATCH
+                |> content (BodyContent.Text data)
+                |> send
+            return response.statusCode, response.responseText
+        }
+
+    /// Safely sends a POST request and returns a tuple(status code * response text). This function does not throw.
+    let post url (data: string) : Async<int * string> =
+        async {
+            let! response =
+                request url
+                |> method HttpMethod.POST
+                |> content (BodyContent.Text data)
+                |> send
+            return response.statusCode, response.responseText
+        }