@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/ts/node_modules/@fable-org/fable-library-js/Uri.js

@@ -0,0 +1,160 @@
+const ok = (value) => ({
+    tag: "ok",
+    value,
+});
+const error = (error) => ({ tag: "error", error });
+class Uri {
+    constructor(state) {
+        this.uri = state;
+    }
+    static isAbsoluteUri(uri) {
+        try {
+            new URL(uri);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static tryCreateWithKind(uri, kind) {
+        switch (kind) {
+            case 1 /* UriKind.Absolute */:
+                return Uri.isAbsoluteUri(uri)
+                    ? ok(new Uri({ original: uri, value: new URL(uri), kind }))
+                    : error("Invalid URI: The format of the URI could not be determined.");
+            case 2 /* UriKind.Relative */:
+                return Uri.isAbsoluteUri(uri)
+                    ? error("URI is not a relative path.")
+                    : ok(new Uri({ original: uri, value: uri, kind }));
+            case 0 /* UriKind.RelativeOrAbsolute */:
+                return Uri.isAbsoluteUri(uri)
+                    ? ok(new Uri({ original: uri, value: new URL(uri), kind: 1 /* UriKind.Absolute */ }))
+                    : ok(new Uri({ original: uri, value: uri, kind: 2 /* UriKind.Relative */ }));
+            default:
+                const never = kind;
+                return never;
+        }
+    }
+    static tryCreateWithBase(baseUri, relativeUri) {
+        return baseUri.uri.kind !== 1 /* UriKind.Absolute */
+            ? error("Base URI should have Absolute kind")
+            : typeof relativeUri === "string"
+                ? ok(new Uri({
+                    original: new URL(relativeUri, baseUri.uri.value).toString(),
+                    value: new URL(relativeUri, baseUri.uri.value),
+                    kind: 1 /* UriKind.Absolute */,
+                }))
+                : relativeUri.uri.kind === 2 /* UriKind.Relative */
+                    ? ok(new Uri({
+                        original: new URL(relativeUri.uri.value, baseUri.uri.value).toString(),
+                        value: new URL(relativeUri.uri.value, baseUri.uri.value),
+                        kind: 1 /* UriKind.Absolute */,
+                    }))
+                    : ok(baseUri);
+    }
+    static tryCreateImpl(value, kindOrUri = 1 /* UriKind.Absolute */) {
+        return typeof value === "string"
+            ? typeof kindOrUri !== "number"
+                ? error("Kind must be specified when the baseUri is a string.")
+                : Uri.tryCreateWithKind(value, kindOrUri)
+            : typeof kindOrUri === "number"
+                ? error("Kind should not be specified when the baseUri is an absolute Uri.")
+                : Uri.tryCreateWithBase(value, kindOrUri);
+    }
+    static create(value, kindOrUri = 1 /* UriKind.Absolute */) {
+        const result = Uri.tryCreateImpl(value, kindOrUri);
+        switch (result.tag) {
+            case "ok":
+                return result.value;
+            case "error":
+                throw new Error(result.error);
+            default:
+                const never = result;
+                return never;
+        }
+    }
+    static tryCreate(value, kindOrUri = 1 /* UriKind.Absolute */, out) {
+        const result = Uri.tryCreateImpl(value, kindOrUri);
+        switch (result.tag) {
+            case "ok":
+                out.contents = result.value;
+                return true;
+            case "error":
+                return false;
+            default:
+                const never = result;
+                return never;
+        }
+    }
+    toString() {
+        switch (this.uri.kind) {
+            case 1 /* UriKind.Absolute */:
+                return decodeURIComponent(this.asUrl().toString());
+            case 2 /* UriKind.Relative */:
+                return this.uri.value;
+            default:
+                const never = this.uri;
+                return never;
+        }
+    }
+    asUrl() {
+        switch (this.uri.kind) {
+            case 1 /* UriKind.Absolute */:
+                return this.uri.value;
+            case 2 /* UriKind.Relative */:
+                throw new Error("This operation is not supported for a relative URI.");
+            default:
+                const never = this.uri;
+                return never;
+        }
+    }
+    get isAbsoluteUri() {
+        return this.uri.kind === 1 /* UriKind.Absolute */;
+    }
+    get absoluteUri() {
+        return this.asUrl().href;
+    }
+    get scheme() {
+        const protocol = this.asUrl().protocol;
+        return protocol.slice(0, protocol.length - 1);
+    }
+    get host() {
+        const host = this.asUrl().host;
+        if (host.includes(":")) {
+            return host.split(":")[0];
+        }
+        else {
+            return host;
+        }
+    }
+    get absolutePath() {
+        return this.asUrl().pathname;
+    }
+    get query() {
+        return this.asUrl().search;
+    }
+    get isDefaultPort() {
+        return this.port === 80;
+    }
+    get port() {
+        const port = this.asUrl().port;
+        if (port === "") {
+            return 80;
+        }
+        else {
+            return parseInt(port);
+        }
+    }
+    get pathAndQuery() {
+        const url = this.asUrl();
+        return url.pathname + url.search;
+    }
+    get fragment() {
+        return this.asUrl().hash;
+    }
+    get originalString() {
+        return this.uri.original;
+    }
+}
+
+export { Uri, Uri as default };

package/dist/ts/node_modules/@fable-org/fable-library-js/Util.js

@@ -0,0 +1,367 @@
+function isArrayLike(x) {
+    return Array.isArray(x) || ArrayBuffer.isView(x);
+}
+function isIterable(x) {
+    return x != null && typeof x === "object" && Symbol.iterator in x;
+}
+function isEnumerable(x) {
+    return x != null && typeof x.GetEnumerator === "function";
+}
+function isComparable(x) {
+    return x != null && typeof x.CompareTo === "function";
+}
+function isEquatable(x) {
+    return x != null && typeof x.Equals === "function";
+}
+function isHashable(x) {
+    return x != null && typeof x.GetHashCode === "function";
+}
+function isDisposable(x) {
+    return x != null && typeof x.Dispose === "function";
+}
+function disposeSafe(x) {
+    if (isDisposable(x)) {
+        x.Dispose();
+    }
+}
+function defaultOf() {
+    return null;
+}
+function sameConstructor(x, y) {
+    return Object.getPrototypeOf(x)?.constructor === Object.getPrototypeOf(y)?.constructor;
+}
+class Enumerator {
+    constructor(iter) {
+        this.iter = iter;
+        this.current = defaultOf();
+    }
+    ["System.Collections.Generic.IEnumerator`1.get_Current"]() {
+        return this.current;
+    }
+    ["System.Collections.IEnumerator.get_Current"]() {
+        return this.current;
+    }
+    ["System.Collections.IEnumerator.MoveNext"]() {
+        const cur = this.iter.next();
+        this.current = cur.value;
+        return !cur.done;
+    }
+    ["System.Collections.IEnumerator.Reset"]() {
+        throw new Error("JS iterators cannot be reset");
+    }
+    Dispose() {
+        return;
+    }
+}
+function getEnumerator(e) {
+    if (isEnumerable(e)) {
+        return e.GetEnumerator();
+    }
+    else {
+        return new Enumerator(e[Symbol.iterator]());
+    }
+}
+function toIterator(en) {
+    return {
+        next() {
+            const hasNext = en["System.Collections.IEnumerator.MoveNext"]();
+            const current = hasNext ? en["System.Collections.Generic.IEnumerator`1.get_Current"]() : undefined;
+            return { done: !hasNext, value: current };
+        },
+    };
+}
+function padWithZeros(i, length) {
+    return i.toString(10).padStart(length, "0");
+}
+function dateOffset(date) {
+    const date1 = date;
+    return typeof date1.offset === "number"
+        ? date1.offset
+        : (date.kind === 1 /* DateKind.UTC */
+            ? 0 : date.getTimezoneOffset() * -6e4);
+}
+function int32ToString(i, radix) {
+    i = i < 0 && radix != null && radix !== 10 ? 0xFFFFFFFF + i + 1 : i;
+    return i.toString(radix);
+}
+class ObjectRef {
+    static id(o) {
+        if (!ObjectRef.idMap.has(o)) {
+            ObjectRef.idMap.set(o, ++ObjectRef.count);
+        }
+        return ObjectRef.idMap.get(o);
+    }
+}
+ObjectRef.idMap = new WeakMap();
+ObjectRef.count = 0;
+function stringHash(s) {
+    let i = 0;
+    let h = 5381;
+    const len = s.length;
+    while (i < len) {
+        h = (h * 33) ^ s.charCodeAt(i++);
+    }
+    return h;
+}
+function numberHash(x) {
+    return x * 2654435761 | 0;
+}
+function bigintHash(x) {
+    return stringHash(x.toString(32));
+}
+// From https://stackoverflow.com/a/37449594
+function combineHashCodes(hashes) {
+    let h1 = 0;
+    const len = hashes.length;
+    for (let i = 0; i < len; i++) {
+        const h2 = hashes[i];
+        h1 = ((h1 << 5) + h1) ^ h2;
+    }
+    return h1;
+}
+function physicalHash(x) {
+    if (x == null) {
+        return 0;
+    }
+    switch (typeof x) {
+        case "boolean":
+            return x ? 1 : 0;
+        case "number":
+            return numberHash(x);
+        case "bigint":
+            return bigintHash(x);
+        case "string":
+            return stringHash(x);
+        default:
+            return numberHash(ObjectRef.id(x));
+    }
+}
+function identityHash(x) {
+    if (isHashable(x)) {
+        return x.GetHashCode();
+    }
+    else {
+        return physicalHash(x);
+    }
+}
+function dateHash(x) {
+    return x.getTime();
+}
+function arrayHash(x) {
+    const len = x.length;
+    const hashes = new Array(len);
+    for (let i = 0; i < len; i++) {
+        hashes[i] = structuralHash(x[i]);
+    }
+    return combineHashCodes(hashes);
+}
+function structuralHash(x) {
+    if (x == null) {
+        return 0;
+    }
+    switch (typeof x) {
+        case "boolean":
+            return x ? 1 : 0;
+        case "number":
+            return numberHash(x);
+        case "bigint":
+            return bigintHash(x);
+        case "string":
+            return stringHash(x);
+        default: {
+            if (isHashable(x)) {
+                return x.GetHashCode();
+            }
+            else if (isArrayLike(x)) {
+                return arrayHash(x);
+            }
+            else if (x instanceof Date) {
+                return dateHash(x);
+            }
+            else if (Object.getPrototypeOf(x)?.constructor === Object) {
+                // TODO: check call-stack to prevent cyclic objects?
+                const hashes = Object.values(x).map((v) => structuralHash(v));
+                return combineHashCodes(hashes);
+            }
+            else {
+                // Classes don't implement GetHashCode by default, but must use identity hashing
+                return numberHash(ObjectRef.id(x));
+                // return stringHash(String(x));
+            }
+        }
+    }
+}
+// Intended for declared types that may or may not implement GetHashCode
+function safeHash(x) {
+    // return x == null ? 0 : isHashable(x) ? x.GetHashCode() : numberHash(ObjectRef.id(x));
+    return identityHash(x);
+}
+function equalArraysWith(x, y, eq) {
+    if (x == null) {
+        return y == null;
+    }
+    if (y == null) {
+        return false;
+    }
+    if (x.length !== y.length) {
+        return false;
+    }
+    for (let i = 0; i < x.length; i++) {
+        if (!eq(x[i], y[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function equalArrays(x, y) {
+    return equalArraysWith(x, y, equals);
+}
+function equalObjects(x, y) {
+    const xKeys = Object.keys(x);
+    const yKeys = Object.keys(y);
+    if (xKeys.length !== yKeys.length) {
+        return false;
+    }
+    xKeys.sort();
+    yKeys.sort();
+    for (let i = 0; i < xKeys.length; i++) {
+        if (xKeys[i] !== yKeys[i] || !equals(x[xKeys[i]], y[yKeys[i]])) {
+            return false;
+        }
+    }
+    return true;
+}
+function equals(x, y) {
+    if (x === y) {
+        return true;
+    }
+    else if (x == null) {
+        return y == null;
+    }
+    else if (y == null) {
+        return false;
+    }
+    else if (isEquatable(x)) {
+        return x.Equals(y);
+    }
+    else if (isArrayLike(x)) {
+        return isArrayLike(y) && equalArrays(x, y);
+    }
+    else if (typeof x !== "object") {
+        return false;
+    }
+    else if (x instanceof Date) {
+        return (y instanceof Date) && compareDates(x, y) === 0;
+    }
+    else {
+        return Object.getPrototypeOf(x)?.constructor === Object && equalObjects(x, y);
+    }
+}
+function compareDates(x, y) {
+    let xtime;
+    let ytime;
+    // DateTimeOffset and DateTime deals with equality differently.
+    if ("offset" in x && "offset" in y) {
+        xtime = x.getTime();
+        ytime = y.getTime();
+    }
+    else {
+        xtime = x.getTime() + dateOffset(x);
+        ytime = y.getTime() + dateOffset(y);
+    }
+    return xtime === ytime ? 0 : (xtime < ytime ? -1 : 1);
+}
+function comparePrimitives(x, y) {
+    return x === y ? 0 : (x < y ? -1 : 1);
+}
+function compareArraysWith(x, y, comp) {
+    if (x == null) {
+        return y == null ? 0 : 1;
+    }
+    if (y == null) {
+        return -1;
+    }
+    if (x.length !== y.length) {
+        return x.length < y.length ? -1 : 1;
+    }
+    for (let i = 0, j = 0; i < x.length; i++) {
+        j = comp(x[i], y[i]);
+        if (j !== 0) {
+            return j;
+        }
+    }
+    return 0;
+}
+function compareArrays(x, y) {
+    return compareArraysWith(x, y, compare);
+}
+function compareObjects(x, y) {
+    const xKeys = Object.keys(x);
+    const yKeys = Object.keys(y);
+    if (xKeys.length !== yKeys.length) {
+        return xKeys.length < yKeys.length ? -1 : 1;
+    }
+    xKeys.sort();
+    yKeys.sort();
+    for (let i = 0, j = 0; i < xKeys.length; i++) {
+        const key = xKeys[i];
+        if (key !== yKeys[i]) {
+            return key < yKeys[i] ? -1 : 1;
+        }
+        else {
+            j = compare(x[key], y[key]);
+            if (j !== 0) {
+                return j;
+            }
+        }
+    }
+    return 0;
+}
+function compare(x, y) {
+    if (x === y) {
+        return 0;
+    }
+    else if (x == null) {
+        return y == null ? 0 : -1;
+    }
+    else if (y == null) {
+        return 1;
+    }
+    else if (isComparable(x)) {
+        return x.CompareTo(y);
+    }
+    else if (isArrayLike(x)) {
+        return isArrayLike(y) ? compareArrays(x, y) : -1;
+    }
+    else if (typeof x !== "object") {
+        return x < y ? -1 : 1;
+    }
+    else if (x instanceof Date) {
+        return y instanceof Date ? compareDates(x, y) : -1;
+    }
+    else {
+        return Object.getPrototypeOf(x)?.constructor === Object ? compareObjects(x, y) : -1;
+    }
+}
+function clear(col) {
+    if (isArrayLike(col)) {
+        col.splice(0);
+    }
+    else {
+        col.clear();
+    }
+}
+const curried = new WeakMap();
+function uncurry2(f) {
+    if (f == null) {
+        return null;
+    }
+    const f2 = (a1, a2) => f(a1)(a2);
+    curried.set(f2, f);
+    return f2;
+}
+function curry2(f) {
+    return curried.get(f) ?? ((a1) => (a2) => f(a1, a2));
+}
+
+export { Enumerator, ObjectRef, arrayHash, bigintHash, clear, combineHashCodes, compare, compareArrays, compareArraysWith, compareDates, comparePrimitives, curry2, dateHash, dateOffset, defaultOf, disposeSafe, equalArrays, equalArraysWith, equals, getEnumerator, identityHash, int32ToString, isArrayLike, isComparable, isDisposable, isEnumerable, isEquatable, isHashable, isIterable, numberHash, padWithZeros, physicalHash, safeHash, sameConstructor, stringHash, structuralHash, toIterator, uncurry2 };