@nfdi4plants/arctrl 1.2.0 → 2.0.0-alpha.2

package/fable_modules/{fable-library-js.4.13.0 → fable-library-js.4.16.0}/Date.js

@@ -9,6 +9,342 @@
  */
 import { toInt64, toFloat64 } from "./BigInt.js";
 import { compareDates, dateOffset, padWithZeros } from "./Util.js";
+const shortDays = [
+    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+];
+const longDays = [
+    "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
+];
+const shortMonths = [
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+];
+const longMonths = [
+    "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
+];
+function parseRepeatToken(format, pos, patternChar) {
+    let tokenLength = 0;
+    let internalPos = pos;
+    while (internalPos < format.length && format[internalPos] === patternChar) {
+        internalPos++;
+        tokenLength++;
+    }
+    return tokenLength;
+}
+function parseNextChar(format, pos) {
+    if (pos >= format.length - 1) {
+        return -1;
+    }
+    return format.charCodeAt(pos + 1);
+}
+function parseQuotedString(format, pos) {
+    let beginPos = pos;
+    // Get the character used to quote the string
+    const quoteChar = format[pos];
+    let result = "";
+    let foundQuote = false;
+    while (pos < format.length) {
+        pos++;
+        const currentChar = format[pos];
+        if (currentChar === quoteChar) {
+            foundQuote = true;
+            break;
+        }
+        else if (currentChar === "\\") {
+            if (pos < format.length) {
+                pos++;
+                result += format[pos];
+            }
+            else {
+                // This means that '\' is the last character in the string.
+                throw new Error("Invalid string format");
+            }
+        }
+        else {
+            result += currentChar;
+        }
+    }
+    if (!foundQuote) {
+        // We could not find the matching quote
+        throw new Error(`Invalid string format could not find matching quote for ${quoteChar}`);
+    }
+    return [result, pos - beginPos + 1];
+}
+function dateToStringWithCustomFormat(date, format, utc) {
+    let cursorPos = 0;
+    let tokenLength = 0;
+    let result = "";
+    const localizedDate = utc ? DateTime(date.getTime(), 1 /* DateKind.UTC */) : date;
+    while (cursorPos < format.length) {
+        const token = format[cursorPos];
+        switch (token) {
+            case "d":
+                tokenLength = parseRepeatToken(format, cursorPos, "d");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += localizedDate.getDate();
+                        break;
+                    case 2:
+                        result += padWithZeros(localizedDate.getDate(), 2);
+                        break;
+                    case 3:
+                        result += shortDays[dayOfWeek(localizedDate)];
+                        break;
+                    case 4:
+                        result += longDays[dayOfWeek(localizedDate)];
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "f":
+                tokenLength = parseRepeatToken(format, cursorPos, "f");
+                cursorPos += tokenLength;
+                if (tokenLength <= 3) {
+                    const precision = 10 ** (3 - tokenLength);
+                    result += padWithZeros(Math.floor(millisecond(localizedDate) / precision), tokenLength);
+                }
+                else if (tokenLength <= 7) {
+                    // JavaScript Date only support precision to the millisecond
+                    // so we fill the rest of the precision with 0 as if the date didn't have
+                    // milliseconds provided to it.
+                    // This is to have the same behavior as .NET when doing:
+                    // DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc).ToString("fffff") => 00000
+                    result += ("" + millisecond(localizedDate)).padEnd(tokenLength, "0");
+                }
+                break;
+            case "F":
+                tokenLength = parseRepeatToken(format, cursorPos, "F");
+                cursorPos += tokenLength;
+                if (tokenLength <= 3) {
+                    const precision = 10 ** (3 - tokenLength);
+                    const value = Math.floor(millisecond(localizedDate) / precision);
+                    if (value != 0) {
+                        result += padWithZeros(value, tokenLength);
+                    }
+                }
+                else if (tokenLength <= 7) {
+                    // JavaScript Date only support precision to the millisecond
+                    // so we can't go beyond that.
+                    // We also need to pad start with 0 if the value is not 0
+                    const value = millisecond(localizedDate);
+                    if (value != 0) {
+                        result += padWithZeros(value, 3);
+                    }
+                }
+                break;
+            case "g":
+                tokenLength = parseRepeatToken(format, cursorPos, "g");
+                cursorPos += tokenLength;
+                if (tokenLength <= 2) {
+                    result += "A.D.";
+                }
+                break;
+            case "h":
+                tokenLength = parseRepeatToken(format, cursorPos, "h");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += hour(localizedDate) % 12;
+                        break;
+                    case 2:
+                        result += padWithZeros(hour(localizedDate) % 12, 2);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "H":
+                tokenLength = parseRepeatToken(format, cursorPos, "H");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += hour(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(hour(localizedDate), 2);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "K":
+                tokenLength = parseRepeatToken(format, cursorPos, "K");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        switch (kind(localizedDate)) {
+                            case 1 /* DateKind.UTC */:
+                                result += "Z";
+                                break;
+                            case 2 /* DateKind.Local */:
+                                result += dateOffsetToString(localizedDate.getTimezoneOffset() * -60000);
+                                break;
+                            case 0 /* DateKind.Unspecified */:
+                                break;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "m":
+                tokenLength = parseRepeatToken(format, cursorPos, "m");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += minute(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(minute(localizedDate), 2);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "M":
+                tokenLength = parseRepeatToken(format, cursorPos, "M");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += month(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(month(localizedDate), 2);
+                        break;
+                    case 3:
+                        result += shortMonths[month(localizedDate) - 1];
+                        break;
+                    case 4:
+                        result += longMonths[month(localizedDate) - 1];
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "s":
+                tokenLength = parseRepeatToken(format, cursorPos, "s");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += second(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(second(localizedDate), 2);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "t":
+                tokenLength = parseRepeatToken(format, cursorPos, "t");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += localizedDate.getHours() < 12 ? "A" : "P";
+                        break;
+                    case 2:
+                        result += localizedDate.getHours() < 12 ? "AM" : "PM";
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "y":
+                tokenLength = parseRepeatToken(format, cursorPos, "y");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += localizedDate.getFullYear() % 100;
+                        break;
+                    case 2:
+                        result += padWithZeros(localizedDate.getFullYear() % 100, 2);
+                        break;
+                    case 3:
+                        result += padWithZeros(localizedDate.getFullYear(), 3);
+                        break;
+                    case 4:
+                        result += padWithZeros(localizedDate.getFullYear(), 4);
+                        break;
+                    case 5:
+                        result += padWithZeros(localizedDate.getFullYear(), 5);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            case "z":
+                tokenLength = parseRepeatToken(format, cursorPos, "z");
+                cursorPos += tokenLength;
+                let utcOffsetText = "";
+                switch (kind(localizedDate)) {
+                    case 1 /* DateKind.UTC */:
+                        utcOffsetText = "+00:00";
+                        break;
+                    case 2 /* DateKind.Local */:
+                        utcOffsetText = dateOffsetToString(localizedDate.getTimezoneOffset() * -60000);
+                        break;
+                    case 0 /* DateKind.Unspecified */:
+                        utcOffsetText = dateOffsetToString(toLocalTime(localizedDate).getTimezoneOffset() * -60000);
+                        break;
+                }
+                const sign = utcOffsetText[0] === "-" ? "-" : "+";
+                const hours = parseInt(utcOffsetText.substring(1, 3), 10);
+                const minutes = parseInt(utcOffsetText.substring(4, 6), 10);
+                switch (tokenLength) {
+                    case 1:
+                        result += `${sign}${hours}`;
+                        break;
+                    case 2:
+                        result += `${sign}${padWithZeros(hours, 2)}`;
+                        break;
+                    default:
+                        result += `${sign}${padWithZeros(hours, 2)}:${padWithZeros(minutes, 2)}`;
+                        break;
+                }
+                break;
+            case ":":
+                result += ":";
+                cursorPos++;
+                break;
+            case "/":
+                result += "/";
+                cursorPos++;
+                break;
+            case "'":
+            case '"':
+                const [quotedString, quotedStringLenght] = parseQuotedString(format, cursorPos);
+                result += quotedString;
+                cursorPos += quotedStringLenght;
+                break;
+            case "%":
+                const nextChar = parseNextChar(format, cursorPos);
+                if (nextChar >= 0 && nextChar !== "%".charCodeAt(0)) {
+                    cursorPos += 2;
+                    result += dateToStringWithCustomFormat(localizedDate, String.fromCharCode(nextChar), utc);
+                }
+                else {
+                    throw new Error("Invalid format string");
+                }
+                break;
+            case "\\":
+                const nextChar2 = parseNextChar(format, cursorPos);
+                if (nextChar2 >= 0) {
+                    cursorPos += 2;
+                    result += String.fromCharCode(nextChar2);
+                }
+                else {
+                    throw new Error("Invalid format string");
+                }
+                break;
+            default:
+                cursorPos++;
+                result += token;
+                break;
+        }
+    }
+    return result;
+}
 export function kind(value) {
     return value.kind || 0;
 }
@@ -54,45 +390,6 @@ function dateToISOStringWithOffset(dateWithOffset, offset) {
     const str = dateWithOffset.toISOString();
     return str.substring(0, str.length - 1) + dateOffsetToString(offset);
 }
-function dateToStringWithCustomFormat(date, format, utc) {
-    return format.replace(/(\w)\1*/g, (match) => {
-        let rep = Number.NaN;
-        switch (match.substring(0, 1)) {
-            case "y":
-                const y = utc ? date.getUTCFullYear() : date.getFullYear();
-                rep = match.length < 4 ? y % 100 : y;
-                break;
-            case "M":
-                rep = (utc ? date.getUTCMonth() : date.getMonth()) + 1;
-                break;
-            case "d":
-                rep = utc ? date.getUTCDate() : date.getDate();
-                break;
-            case "H":
-                rep = utc ? date.getUTCHours() : date.getHours();
-                break;
-            case "h":
-                const h = utc ? date.getUTCHours() : date.getHours();
-                rep = h > 12 ? h % 12 : h;
-                break;
-            case "m":
-                rep = utc ? date.getUTCMinutes() : date.getMinutes();
-                break;
-            case "s":
-                rep = utc ? date.getUTCSeconds() : date.getSeconds();
-                break;
-            case "f":
-                rep = utc ? date.getUTCMilliseconds() : date.getMilliseconds();
-                break;
-        }
-        if (Number.isNaN(rep)) {
-            return match;
-        }
-        else {
-            return padWithZeros(rep, match.length);
-        }
-    });
-}
 function dateToStringWithOffset(date, format) {
     const d = new Date(date.getTime() + (date.offset ?? 0));
     if (typeof format !== "string") {
@@ -358,7 +655,7 @@ export function dayOfYear(d) {
 }
 export function add(d, ts) {
     const newDate = DateTime(d.getTime() + ts, d.kind);
-    if (d.kind === 2 /* DateKind.Local */) {
+    if (d.kind !== 1 /* DateKind.UTC */) {
         const oldTzOffset = d.getTimezoneOffset();
         const newTzOffset = newDate.getTimezoneOffset();
         return oldTzOffset !== newTzOffset

package/fable_modules/fable-library-js.4.16.0/MapUtil.d.ts

@@ -0,0 +1,12 @@
+import { IMap, IMapOrWeakMap, ISet } from "./Util.js";
+import { FSharpRef } from "./Types.js";
+export declare function keyValueList(fields: Iterable<any>, caseRule?: number): {
+    [k: string]: any;
+};
+export declare function containsValue<K, V>(v: V, map: IMap<K, V>): boolean;
+export declare function tryGetValue<K, V>(map: IMapOrWeakMap<K, V>, key: K, defaultValue: FSharpRef<V>): boolean;
+export declare function addToSet<T>(v: T, set: ISet<T>): boolean;
+export declare function tryAddToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V): boolean;
+export declare function addToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V): void;
+export declare function getItemFromDict<K, V>(map: IMap<K, V>, key: K): V;
+export declare function getItemFromDictOrCreate<K, V>(map: IMapOrWeakMap<K, V>, key: K, createValue: (key: K) => V): V;

package/fable_modules/{fable-library-js.4.13.0 → fable-library-js.4.16.0}/MapUtil.js

@@ -96,6 +96,13 @@ export function addToSet(v, set) {
     set.add(v);
     return true;
 }
+export function tryAddToDict(dict, k, v) {
+    if (dict.has(k)) {
+        return false;
+    }
+    dict.set(k, v);
+    return true;
+}
 export function addToDict(dict, k, v) {
     if (dict.has(k)) {
         throw new Error("An item with the same key has already been added. Key: " + k);
@@ -110,3 +117,11 @@ export function getItemFromDict(map, key) {
         throw new Error(`The given key '${key}' was not present in the dictionary.`);
     }
 }
+export function getItemFromDictOrCreate(map, key, createValue) {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    const value = createValue(key);
+    map.set(key, value);
+    return value;
+}

package/fable_modules/{fable-library-js.4.13.0 → fable-library-js.4.16.0}/Util.d.ts

@@ -93,13 +93,16 @@ export interface ISet<T> {
     keys(): Iterable<T>;
     values(): Iterable<T>;
 }
-export interface IMap<K, V> {
-    clear(): void;
+export interface IMapOrWeakMap<K, V> {
     delete(key: K): boolean;
-    forEach(callbackfn: (value: V, key: K, map: IMap<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
+    set(key: K, value: V): IMapOrWeakMap<K, V>;
+}
+export interface IMap<K, V> extends IMapOrWeakMap<K, V> {
+    clear(): void;
     set(key: K, value: V): IMap<K, V>;
+    forEach(callbackfn: (value: V, key: K, map: IMap<K, V>) => void, thisArg?: any): void;
     readonly size: number;
     [Symbol.iterator](): Iterator<[K, V]>;
     entries(): Iterable<[K, V]>;

package/fable_modules/{fable-library-js.4.13.0 → fable-library-js.4.16.0}/Util.js

@@ -159,21 +159,10 @@ export function lazyFromValue(v) {
     return new Lazy(() => v);
 }
 export function padWithZeros(i, length) {
-    let str = i.toString(10);
-    while (str.length < length) {
-        str = "0" + str;
-    }
-    return str;
+    return i.toString(10).padStart(length, "0");
 }
 export function padLeftAndRightWithZeros(i, lengthLeft, lengthRight) {
-    let str = i.toString(10);
-    while (str.length < lengthLeft) {
-        str = "0" + str;
-    }
-    while (str.length < lengthRight) {
-        str = str + "0";
-    }
-    return str;
+    return i.toString(10).padStart(lengthLeft, "0").padEnd(lengthRight, "0");
 }
 export function dateOffset(date) {
     const date1 = date;

package/fable_modules/{fable-library-js.4.13.0 → fable-library-js.4.16.0}/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "name": "@fable-org/fable-library-js",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "description": "Core library used by F# projects compiled with fable.io",
   "author": "Fable Contributors",
   "license": "MIT",