@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/dist/ts/esm/ts/fable_modules/Fable.Promise.3.2.0/Promise.fs.js

@@ -0,0 +1,203 @@
+import { Result_MapError, Result_Map, FSharpResult$2_Error, FSharpResult$2_Ok } from "@fable-org/fable-library-js/Result.js";
+import { class_type } from "@fable-org/fable-library-js/Reflection.js";
+import { disposeSafe, getEnumerator } from "@fable-org/fable-library-js/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(FSharpResult$2_Ok).catch(FSharpResult$2_Error);
+}
+/**
+ * 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 === /* Error */ 1) {
+            const e = a_1.fields[0];
+            return Promise.resolve(FSharpResult$2_Error(e));
+        }
+        else {
+            const pr = fn(a_1.fields[0]);
+            return pr.then(FSharpResult$2_Ok);
+        }
+    });
+}
+/**
+ * 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", undefined, PromiseBuilder);
+}
+export function PromiseBuilder_$ctor() {
+    return new PromiseBuilder();
+}
+export function PromiseBuilder__For_1565554B(_, seq, body) {
+    let pr;
+    let p = Promise.resolve(undefined);
+    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(undefined);
+    }
+}
+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/dist/ts/esm/ts/fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs.js

@@ -0,0 +1,16 @@
+import { PromiseBuilder_$ctor } from "./Promise.fs.js";
+import { value } from "@fable-org/fable-library-js/Option.js";
+import { FSharpResult$2_Ok, FSharpResult$2_Error } from "@fable-org/fable-library-js/Result.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 FSharpResult$2_Error(value(p.reason));
+    }
+    else {
+        return FSharpResult$2_Ok(value(p.value));
+    }
+}

package/dist/ts/esm/ts/fable_modules/Fable.SimpleHttp.3.5.0/Http.fs.js

@@ -0,0 +1,380 @@
+import { fromContinuations } from "@fable-org/fable-library-js/Async.js";
+import { singleton as singleton_1 } from "@fable-org/fable-library-js/AsyncBuilder.js";
+import { HttpMethod_POST, HttpMethod_PATCH, HttpMethod_DELETE, HttpMethod_PUT, BodyContent_Text, ResponseContent_Unknown, ResponseContent_Blob, ResponseContent_ArrayBuffer, HttpResponse, ResponseContent_Text, HttpRequest, BodyContent_Empty, HttpMethod_GET, Header } from "./Types.fs.js";
+import { tail, head, isEmpty, ofArray as ofArray_1, singleton, append, empty } from "@fable-org/fable-library-js/List.js";
+import { ofArray, empty as empty_1 } from "@fable-org/fable-library-js/Map.js";
+import { disposeSafe, getEnumerator, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
+import { join, split, isNullOrEmpty } from "@fable-org/fable-library-js/String.js";
+import { choose } from "@fable-org/fable-library-js/Array.js";
+import { some, value as value_2 } from "@fable-org/fable-library-js/Option.js";
+/**
+ * Download a Blob
+ */
+export function Blob_download(blob, fileName) {
+    const element = document.createElement("a");
+    element.target = "_blank";
+    element.href = (window.URL.createObjectURL(blob));
+    element.setAttribute("download", fileName);
+    document.body.appendChild(element);
+    element.click();
+    document.body.removeChild(element);
+}
+/**
+ * Asynchronously reads the blob data content as string
+ */
+export function FileReader_readBlobAsText(blob) {
+    return fromContinuations((tupledArg) => {
+        const reader = new FileReader();
+        reader.onload = ((_arg_2) => {
+            if (reader.readyState === 2) {
+                tupledArg[0](reader.result);
+            }
+        });
+        reader.readAsText(blob);
+    });
+}
+/**
+ * Asynchronously reads the blob data content as string
+ */
+export function FileReader_readFileAsText(file) {
+    return fromContinuations((tupledArg) => {
+        const reader = new FileReader();
+        reader.onload = ((_arg_2) => {
+            if (reader.readyState === 2) {
+                tupledArg[0](reader.result);
+            }
+        });
+        reader.readAsText(file);
+    });
+}
+/**
+ * Appends a key-value pair to the form data
+ */
+export function FormData_append(key, value, form) {
+    form.append(key, value);
+    return form;
+}
+/**
+ * Appends a file to the form data
+ */
+export function FormData_appendFile(key, file, form) {
+    form.append(key, file);
+    return form;
+}
+/**
+ * Appends a named file to the form data
+ */
+export function FormData_appendNamedFile(key, fileName, file, form) {
+    form.append(key, file, fileName);
+    return form;
+}
+/**
+ * Appends a blog to the form data
+ */
+export function FormData_appendBlob(key, blob, form) {
+    form.append(key, blob);
+    return form;
+}
+/**
+ * Appends a blog to the form data
+ */
+export function FormData_appendNamedBlob(key, fileName, blob, form) {
+    form.append(key, blob, fileName);
+    return form;
+}
+export function Headers_contentType(value) {
+    return new Header("Content-Type", value);
+}
+export function Headers_accept(value) {
+    return new Header("Accept", value);
+}
+export function Headers_acceptCharset(value) {
+    return new Header("Accept-Charset", value);
+}
+export function Headers_acceptEncoding(value) {
+    return new Header("Accept-Encoding", value);
+}
+export function Headers_acceptLanguage(value) {
+    return new Header("Accept-Language", value);
+}
+export function Headers_acceptDateTime(value) {
+    return new Header("Accept-Datetime", value);
+}
+export function Headers_authorization(value) {
+    return new Header("Authorization", value);
+}
+export function Headers_cacheControl(value) {
+    return new Header("Cache-Control", value);
+}
+export function Headers_connection(value) {
+    return new Header("Connection", value);
+}
+export function Headers_cookie(value) {
+    return new Header("Cookie", value);
+}
+export function Headers_contentMD5(value) {
+    return new Header("Content-MD5", value);
+}
+export function Headers_date(value) {
+    return new Header("Date", value);
+}
+export function Headers_expect(value) {
+    return new Header("Expect", value);
+}
+export function Headers_ifMatch(value) {
+    return new Header("If-Match", value);
+}
+export function Headers_ifModifiedSince(value) {
+    return new Header("If-Modified-Since", value);
+}
+export function Headers_ifNoneMatch(value) {
+    return new Header("If-None-Match", value);
+}
+export function Headers_ifRange(value) {
+    return new Header("If-Range", value);
+}
+export function Headers_IfUnmodifiedSince(value) {
+    return new Header("If-Unmodified-Since", value);
+}
+export function Headers_maxForwards(value) {
+    return new Header("Max-Forwards", value);
+}
+export function Headers_origin(value) {
+    return new Header("Origin", value);
+}
+export function Headers_pragma(value) {
+    return new Header("Pragma", value);
+}
+export function Headers_proxyAuthorization(value) {
+    return new Header("Proxy-Authorization", value);
+}
+export function Headers_range(value) {
+    return new Header("Range", value);
+}
+export function Headers_referer(value) {
+    return new Header("Referer", value);
+}
+export function Headers_userAgent(value) {
+    return new Header("User-Agent", value);
+}
+export function Headers_create(key, value) {
+    return new Header(key, value);
+}
+const Http_defaultRequest = new HttpRequest("", HttpMethod_GET(), empty(), false, undefined, undefined, undefined, BodyContent_Empty());
+const Http_emptyResponse = new HttpResponse(0, "", "", "", empty_1({
+    Compare: comparePrimitives,
+}), ResponseContent_Text(""));
+function Http_splitAt(delimiter, input) {
+    if (isNullOrEmpty(input)) {
+        return [input];
+    }
+    else {
+        return split(input, [delimiter], undefined, 0);
+    }
+}
+function Http_serializeMethod(_arg) {
+    switch (_arg.tag) {
+        case /* POST */ 1:
+            return "POST";
+        case /* PATCH */ 3:
+            return "PATCH";
+        case /* PUT */ 2:
+            return "PUT";
+        case /* DELETE */ 4:
+            return "DELETE";
+        case /* OPTIONS */ 6:
+            return "OPTIONS";
+        case /* HEAD */ 5:
+            return "HEAD";
+        default:
+            return "GET";
+    }
+}
+/**
+ * Starts the configuration of the request with the specified url
+ */
+export function Http_request(url) {
+    return new HttpRequest(url, Http_defaultRequest.method, Http_defaultRequest.headers, Http_defaultRequest.withCredentials, Http_defaultRequest.overridenMimeType, Http_defaultRequest.overridenResponseType, Http_defaultRequest.timeout, Http_defaultRequest.content);
+}
+/**
+ * Sets the Http method of the request
+ */
+export function Http_method(httpVerb, req) {
+    return new HttpRequest(req.url, httpVerb, req.headers, req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Appends a header to the request configuration
+ */
+export function Http_header(singleHeader, req) {
+    return new HttpRequest(req.url, req.method, append(req.headers, singleton(singleHeader)), req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Appends a list of headers to the request configuration
+ */
+export function Http_headers(values, req) {
+    return new HttpRequest(req.url, req.method, append(req.headers, values), req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Enables cross-site credentials such as cookies
+ */
+export function Http_withCredentials(enabled, req) {
+    return new HttpRequest(req.url, req.method, req.headers, enabled, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Enables Http request timeout
+ */
+export function Http_withTimeout(timeoutInMilliseconds, req) {
+    return new HttpRequest(req.url, req.method, req.headers, req.withCredentials, req.overridenMimeType, req.overridenResponseType, timeoutInMilliseconds, req.content);
+}
+/**
+ * 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.
+ */
+export function Http_overrideMimeType(value, req) {
+    return new HttpRequest(req.url, req.method, req.headers, req.withCredentials, value, req.overridenResponseType, req.timeout, req.content);
+}
+/**
+ * Change the expected response type from the server
+ */
+export function Http_overrideResponseType(value, req) {
+    return new HttpRequest(req.url, req.method, req.headers, req.withCredentials, req.overridenMimeType, value, req.timeout, req.content);
+}
+/**
+ * Sets the body content of the request
+ */
+export function Http_content(bodyContent, req) {
+    return new HttpRequest(req.url, req.method, req.headers, req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, bodyContent);
+}
+/**
+ * Sends the request to the server, this function does not throw
+ */
+export function Http_send(req) {
+    return fromContinuations((tupledArg) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open(Http_serializeMethod(req.method), req.url);
+        xhr.onreadystatechange = (() => {
+            let responseText, matchValue, statusCode, responseType, content, matchValue_1, responseHeaders;
+            if (xhr.readyState === 4) {
+                tupledArg[0]((responseText = ((matchValue = xhr.responseType, (matchValue === "") ? xhr.responseText : ((matchValue === "text") ? xhr.responseText : ""))), (statusCode = (xhr.status | 0), (responseType = xhr.responseType, (content = ((matchValue_1 = xhr.responseType, (matchValue_1 === "") ? ResponseContent_Text(xhr.responseText) : ((matchValue_1 === "text") ? ResponseContent_Text(xhr.responseText) : ((matchValue_1 === "arraybuffer") ? ResponseContent_ArrayBuffer(xhr.response) : ((matchValue_1 === "blob") ? ResponseContent_Blob(xhr.response) : ResponseContent_Unknown(xhr.response)))))), (responseHeaders = ofArray(choose((headerLine) => {
+                    const matchValue_2 = ofArray_1(Http_splitAt(":", headerLine));
+                    if (!isEmpty(matchValue_2)) {
+                        return [head(matchValue_2).toLocaleLowerCase(), join(":", tail(matchValue_2)).trim()];
+                    }
+                    else {
+                        return undefined;
+                    }
+                }, Http_splitAt("\r\n", xhr.getAllResponseHeaders())), {
+                    Compare: comparePrimitives,
+                }), new HttpResponse(statusCode, responseText, responseType, xhr.responseURL, responseHeaders, content)))))));
+            }
+        });
+        const enumerator = getEnumerator(req.headers);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                const value = forLoopVar.fields[1];
+                const key_1 = forLoopVar.fields[0];
+                xhr.setRequestHeader(key_1, value);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+        xhr.withCredentials = req.withCredentials;
+        const matchValue_3 = req.overridenMimeType;
+        if (matchValue_3 == null) {
+        }
+        else {
+            const mimeType = value_2(matchValue_3);
+            xhr.overrideMimeType(mimeType);
+        }
+        const matchValue_4 = req.overridenResponseType;
+        if (matchValue_4 == null) {
+        }
+        else {
+            switch (value_2(matchValue_4).tag) {
+                case /* Blob */ 1: {
+                    xhr.responseType = "blob";
+                    break;
+                }
+                case /* ArrayBuffer */ 2: {
+                    xhr.responseType = "arraybuffer";
+                    break;
+                }
+                default:
+                    xhr.responseType = "text";
+            }
+        }
+        const matchValue_5 = req.timeout;
+        if (matchValue_5 == null) {
+        }
+        else {
+            const timeout = value_2(matchValue_5) | 0;
+            xhr.timeout = (timeout | 0);
+        }
+        const matchValue_6 = req.content;
+        switch (matchValue_6.tag) {
+            case /* Text */ 1: {
+                const value_1 = matchValue_6.fields[0];
+                xhr.send(some(value_1));
+                break;
+            }
+            case /* Form */ 3: {
+                const formData = matchValue_6.fields[0];
+                xhr.send(some(formData));
+                break;
+            }
+            case /* Binary */ 2: {
+                const blob = matchValue_6.fields[0];
+                xhr.send(some(blob));
+                break;
+            }
+            default:
+                xhr.send();
+        }
+    });
+}
+/**
+ * Safely sends a GET request and returns a tuple(status code * response text). This function does not throw.
+ */
+export function Http_get(url) {
+    return singleton_1.Delay(() => singleton_1.Bind(Http_send(Http_method(HttpMethod_GET(), Http_request(url))), (_arg) => {
+        const response = _arg;
+        return singleton_1.Return([response.statusCode, response.responseText]);
+    }));
+}
+/**
+ * Safely sends a PUT request and returns a tuple(status code * response text). This function does not throw.
+ */
+export function Http_put(url, data) {
+    return singleton_1.Delay(() => singleton_1.Bind(Http_send(Http_content(BodyContent_Text(data), Http_method(HttpMethod_PUT(), Http_request(url)))), (_arg) => {
+        const response = _arg;
+        return singleton_1.Return([response.statusCode, response.responseText]);
+    }));
+}
+/**
+ * Safely sends a DELETE request and returns a tuple(status code * response text). This function does not throw.
+ */
+export function Http_delete(url) {
+    return singleton_1.Delay(() => singleton_1.Bind(Http_send(Http_method(HttpMethod_DELETE(), Http_request(url))), (_arg) => {
+        const response = _arg;
+        return singleton_1.Return([response.statusCode, response.responseText]);
+    }));
+}
+/**
+ * Safely sends a PATCH request and returns a tuple(status code * response text). This function does not throw.
+ */
+export function Http_patch(url, data) {
+    return singleton_1.Delay(() => singleton_1.Bind(Http_send(Http_content(BodyContent_Text(data), Http_method(HttpMethod_PATCH(), Http_request(url)))), (_arg) => {
+        const response = _arg;
+        return singleton_1.Return([response.statusCode, response.responseText]);
+    }));
+}
+/**
+ * Safely sends a POST request and returns a tuple(status code * response text). This function does not throw.
+ */
+export function Http_post(url, data) {
+    return singleton_1.Delay(() => singleton_1.Bind(Http_send(Http_content(BodyContent_Text(data), Http_method(HttpMethod_POST(), Http_request(url)))), (_arg) => {
+        const response = _arg;
+        return singleton_1.Return([response.statusCode, response.responseText]);
+    }));
+}