@nfdi4plants/arctrl 2.0.0-beta.2 → 2.0.0

package/fable_modules/YAMLicious.0.0.1/Encode.fs

@@ -0,0 +1,148 @@
+/// To YAML
+[<RequireQualifiedAccessAttribute>]
+module YAMLicious.Encode
+
+open System
+open System.Collections.Generic
+open System.Globalization
+
+open YAMLicious
+open YAMLicious.YAMLiciousTypes
+
+module Helper =
+
+    let inline getUnionCaseName (x:'a) = 
+        match Microsoft.FSharp.Reflection.FSharpValue.GetUnionFields(x, typeof<'a>) with
+        | case, _ -> case.Name
+
+let int (value: int) = (YAMLContent.create(string value)) |> YAMLElement.Value
+
+let float (value: float) = (YAMLContent.create(value.ToString("O", CultureInfo.InvariantCulture))) |> YAMLElement.Value
+
+let char (value: char) = YAMLContent.create(string value) |> YAMLElement.Value
+
+let bool (value: bool) = YAMLContent.create(string value) |> YAMLElement.Value
+
+let inline map (keyEncoder: 'a -> string) (valueEncoder: 'b -> YAMLElement) (value: Map<'a, 'b>) = 
+    [
+        for KeyValue (k, v) in value do 
+            YAMLElement.Mapping (YAMLContent.create(keyEncoder k), valueEncoder v) 
+    ] 
+    |> YAMLElement.Object
+
+let inline dict (keyEncoder: 'a -> string) (valueEncoder: 'b -> YAMLElement) (value: Dictionary<'a, 'b>) = 
+    [for KeyValue (k, v) in value do 
+        YAMLElement.Mapping (YAMLContent.create(keyEncoder k), valueEncoder v) 
+    ] |> YAMLElement.Object
+
+let datetime (value: DateTime) = (YAMLContent.create(value.ToString("O", CultureInfo.InvariantCulture))) |> YAMLElement.Value
+
+let datetimeOffset (value: DateTimeOffset) = (YAMLContent.create(value.ToString("O", CultureInfo.InvariantCulture))) |> YAMLElement.Value
+
+let inline option (enc: 'a -> YAMLElement) (value: 'a option) = 
+    match value with
+    | Some v -> enc v
+    | None -> YAMLElement.Value <| YAMLContent.create YAML_NULL
+
+let inline tuple2 (encA: 'a -> YAMLElement) (encB: 'b -> YAMLElement) (value: 'a * 'b) = YAMLElement.Sequence [encA (fst value); encB (snd value)]
+
+let inline tuple3 (encA: 'a -> YAMLElement) (encB: 'b -> YAMLElement) (encC: 'c -> YAMLElement) (value: 'a * 'b * 'c) = 
+    let a,b,c = value
+    YAMLElement.Sequence [encA a; encB b; encC c]
+
+let inline tuple4 (encA: 'a -> YAMLElement) (encB: 'b -> YAMLElement) (encC: 'c -> YAMLElement) (encD: 'd -> YAMLElement) (value: 'a * 'b * 'c * 'd) = 
+    let a,b,c,d = value
+    YAMLElement.Sequence [encA a; encB b; encC c; encD d]
+
+let inline tuple5 (encA: 'a -> YAMLElement) (encB: 'b -> YAMLElement) (encC: 'c -> YAMLElement) (encD: 'd -> YAMLElement) (encE: 'e -> YAMLElement) (value: 'a * 'b * 'c * 'd * 'e) = 
+    let a,b,c,d,e = value
+    YAMLElement.Sequence [encA a; encB b; encC c; encD d; encE e]
+
+let inline tuple6 
+    (encA: 'a -> YAMLElement) 
+    (encB: 'b -> YAMLElement) 
+    (encC: 'c -> YAMLElement) 
+    (encD: 'd -> YAMLElement) 
+    (encE: 'e -> YAMLElement) 
+    (encF: 'f -> YAMLElement) 
+    (value: 'a * 'b * 'c * 'd * 'e * 'f) 
+    = 
+    let a,b,c,d,e,f = value
+    YAMLElement.Sequence [encA a; encB b; encC c; encD d; encE e; encF f]
+
+let inline tuple7 
+    (encA: 'a -> YAMLElement) 
+    (encB: 'b -> YAMLElement) 
+    (encC: 'c -> YAMLElement) 
+    (encD: 'd -> YAMLElement) 
+    (encE: 'e -> YAMLElement) 
+    (encF: 'f -> YAMLElement) 
+    (encG: 'g -> YAMLElement) 
+    (value: 'a * 'b * 'c * 'd * 'e * 'f * 'g) 
+    = 
+    let a,b,c,d,e,f,g = value
+    YAMLElement.Sequence [encA a; encB b; encC c; encD d; encE e; encF f; encG g]
+
+let inline tuple8 
+    (encA: 'a -> YAMLElement) 
+    (encB: 'b -> YAMLElement) 
+    (encC: 'c -> YAMLElement) 
+    (encD: 'd -> YAMLElement) 
+    (encE: 'e -> YAMLElement) 
+    (encF: 'f -> YAMLElement) 
+    (encG: 'g -> YAMLElement) 
+    (encH: 'h -> YAMLElement)
+    (value: 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h)
+    = 
+    let a,b,c,d,e,f,g,h = value
+    YAMLElement.Sequence [encA a; encB b; encC c; encD d; encE e; encF f; encG g; encH h]
+
+let string (value: string) = (YAMLContent.create(value)) |> YAMLElement.Value
+
+let seq (encoder: 'a -> YAMLElement) (s: seq<'a>) = s |> Seq.map encoder |> List.ofSeq |> YAMLElement.Sequence
+
+let array (encoder: 'a -> YAMLElement) (arr: 'a []) = YAMLElement.Sequence (List.map encoder (List.ofArray arr))
+
+let resizearray (encoder: 'a -> YAMLElement) (arr: ResizeArray<'a>) = YAMLElement.Sequence (List.map encoder (List.ofSeq arr))
+
+let list (encoder: 'a -> YAMLElement) (l: 'a list) = YAMLElement.Sequence (List.map encoder l)
+
+let values (encoder: 'a -> string) (values: 'a seq) = 
+    values 
+    |> Seq.map (encoder >> YAMLContent.create >> YAMLElement.Value) 
+    |> List.ofSeq 
+    |> YAMLElement.Object
+
+let inline object (objSeq: #seq<(string*YAMLElement)>) = 
+    [
+        for (key, v) in objSeq do 
+            YAMLElement.Mapping (YAMLContent.create(key), v) 
+    ]
+    |> YAMLElement.Object
+
+let inline withComment (comment: string) (ele: YAMLElement) = 
+    match ele with
+    | YAMLElement.Value v -> YAMLElement.Value {v with Comment = Some comment}
+    | YAMLElement.Mapping (k, v) -> YAMLElement.Mapping ({k with Comment = Some comment}, v)
+    | anyElse -> invalidArg "ele" (sprintf "Unsupported element type for `Encode.withComment`: %s" (Helper.getUnionCaseName anyElse))
+
+let comment (string) = string |> YAMLElement.Comment
+
+let nil = YAMLElement.Nil
+
+/// Try to encode the given object using the given encoder, or return Encode.nil if the object is null
+let tryInclude (name : string) (encoder : 'a -> YAMLElement) (value : 'a option) = 
+    name,
+    match value with
+    | Some(o) -> encoder o
+    | _ -> nil
+
+let inline choose (kvs : (string * YAMLElement) list) = 
+    kvs
+    |> List.choose (fun (k,v) -> 
+        if v = YAMLElement.Nil then None
+        else Some (k,v)
+    )
+
+let write (whitespaces: int) (ele: YAMLElement) =
+    Writer.write ele (Some (fun c -> {c with Whitespace = whitespaces}))

package/fable_modules/YAMLicious.0.0.1/Encode.fs.js

@@ -0,0 +1,74 @@
+import { Config, YAMLElement, YAMLContent_create_27AED5E3 } from "./YAMLiciousTypes.fs.js";
+import { int32ToString } from "../fable-library-js.4.16.0/Util.js";
+import { toString } from "../fable-library-js.4.16.0/Types.js";
+import { toString as toString_1 } from "../fable-library-js.4.16.0/Date.js";
+import { ofArray, map as map_1, ofSeq } from "../fable-library-js.4.16.0/List.js";
+import { map } from "../fable-library-js.4.16.0/Seq.js";
+import { value as value_1 } from "../fable-library-js.4.16.0/Option.js";
+import { write as write_1 } from "./Writer.fs.js";
+
+export function int(value) {
+    return new YAMLElement(1, [YAMLContent_create_27AED5E3(int32ToString(value))]);
+}
+
+export function float(value) {
+    return new YAMLElement(1, [YAMLContent_create_27AED5E3(String(value))]);
+}
+
+export function char(value) {
+    return new YAMLElement(1, [YAMLContent_create_27AED5E3(value)]);
+}
+
+export function bool(value) {
+    return new YAMLElement(1, [YAMLContent_create_27AED5E3(toString(value))]);
+}
+
+export function datetime(value) {
+    return new YAMLElement(1, [YAMLContent_create_27AED5E3(toString_1(value, "O", {}))]);
+}
+
+export function datetimeOffset(value) {
+    return new YAMLElement(1, [YAMLContent_create_27AED5E3(toString_1(value, "O", {}))]);
+}
+
+export function string(value) {
+    return new YAMLElement(1, [YAMLContent_create_27AED5E3(value)]);
+}
+
+export function seq(encoder, s) {
+    return new YAMLElement(2, [ofSeq(map(encoder, s))]);
+}
+
+export function array(encoder, arr) {
+    return new YAMLElement(2, [map_1(encoder, ofArray(arr))]);
+}
+
+export function resizearray(encoder, arr) {
+    return new YAMLElement(2, [map_1(encoder, ofSeq(arr))]);
+}
+
+export function list(encoder, l) {
+    return new YAMLElement(2, [map_1(encoder, l)]);
+}
+
+export function values(encoder, values_1) {
+    return new YAMLElement(3, [ofSeq(map((arg_1) => (new YAMLElement(1, [YAMLContent_create_27AED5E3(encoder(arg_1))])), values_1))]);
+}
+
+export function comment(string_1) {
+    return new YAMLElement(4, [string_1]);
+}
+
+export const nil = new YAMLElement(5, []);
+
+/**
+ * Try to encode the given object using the given encoder, or return Encode.nil if the object is null
+ */
+export function tryInclude(name, encoder, value) {
+    return [name, (value != null) ? encoder(value_1(value)) : nil];
+}
+
+export function write(whitespaces, ele) {
+    return write_1(ele, (c) => (new Config(whitespaces, c.Level)));
+}
+

package/fable_modules/YAMLicious.0.0.1/Interop/JsInterop.fs

@@ -0,0 +1,14 @@
+[<RequireQualifiedAccessAttribute>]
+module YAMLicious.JsInterop
+
+#if FABLE_COMPILER_JAVASCRIPT || FABLE_COMPILER_TYPESCRIPT
+open Fable.Core.JsInterop
+
+let isInt (s:string): bool =
+    emitJsStatement (s) """if (typeof $0 != "string") return false // we only process strings!  
+                return !isNaN($0) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+                       !isNaN(parseFloat($0)) // ...and ensure strings of whitespace fail"""
+
+let isString (s:string): bool =
+    emitJsStatement s """return typeof $0 === 'string' || value instanceof String"""
+#endif

package/fable_modules/YAMLicious.0.0.1/Interop/JsInterop.fs.js

@@ -0,0 +1,11 @@
+
+export function isInt(s) {
+    if (typeof s != "string") return false // we only process strings!  
+                return !isNaN(s) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+                       !isNaN(parseFloat(s)) // ...and ensure strings of whitespace fail;
+}
+
+export function isString(s) {
+    return typeof s === 'string' || value instanceof String;
+}
+

package/fable_modules/YAMLicious.0.0.1/Interop/PyInterop.fs

@@ -0,0 +1,9 @@
+[<RequireQualifiedAccessAttribute>]
+module YAMLicious.PyInterop
+
+#if FABLE_COMPILER_PYTHON
+open Fable.Core.PyInterop
+
+let isString (s:string): bool =
+    emitPyStatement s """return isinstance($0, str)"""
+#endif

package/fable_modules/YAMLicious.0.0.1/Library.fs

@@ -0,0 +1,138 @@
+namespace YAMLicious
+
+open YAMLiciousTypes
+
+module TestCases =
+
+    [<Literal>]
+    let KeyValue = """
+My Key: My Value    
+"""
+
+    [<Literal>]
+    let String = """
+My Value
+"""
+
+    [<Literal>]
+    let Sequence = """
+- My Value 1
+- My Value 2
+- My Value 3
+"""
+
+    [<Literal>]
+    let SequenceObjects = """
+- My Value 1
+  My Value 2
+- My Value 3
+"""
+
+    [<Literal>]
+    let SequenceImplicit = """
+My Key:
+  My Value1
+  My Value2
+  My Value3
+"""
+
+    [<Literal>]
+    let SequenceSameIndentAsMapping = """
+My Key:
+- My Value1
+- My Value2
+- My Value3
+"""
+    [<Literal>]
+    let SequenceMappings = """
+-
+  My Key1: My Value1
+  My Key2: My Value2
+  My Key3: My Value3
+-
+  My Key4: My Value4
+  My Key5: My Value5
+  My Key6: My Value6
+"""
+
+    [<Literal>]
+    let SequenceOfSequences = """
+- [v1, v2, v3]
+- [v4, v5, v6]
+- [v7, v8, v9]
+""" 
+
+    [<Literal>]
+    let SequenceOfSequences2 = """
+- 
+  [v1, v2, v3]
+- 
+  [v4, v5, v6]
+- 
+  [v7, v8, v9]
+"""
+ 
+    [<Literal>]
+    let SequenceSquare = """
+[
+  v1,
+  v2,
+  v3
+]
+"""
+    
+    let SequenceMappingsAST = 
+        Level [
+            Line "-"
+            Intendation [
+                Line "My Key1: My Value1"
+                Line "My Key2: My Value2"
+                Line "My Key3: My Value3"
+            ]
+            Line "-"
+            Intendation [
+                Line "My Key4: My Value4"
+                Line "My Key5: My Value5"
+                Line "My Key6: My Value6"
+            ]
+        ]
+
+    [<Literal>]
+    let LineComment = """
+# This is a line comment    
+"""
+
+    [<Literal>]
+    let InlineComment = """
+My Key: # This is a comment
+  My Value1 
+  My Value2
+  My Value3 # :::: This is also a comment
+"""
+
+    [<Literal>]
+    let StringReplace = """
+My Key: "[{Special character place # |}"
+"""
+
+    let StringReplaceClean = """
+My Key: </1>
+"""
+
+    [<Literal>]
+    let StringReplaceWithComment = """
+My Key: "[{Special character place # |}" # A # in string is allowed!
+"""
+
+    [<Literal>]
+    let StringReplaceWithCommentHashs = """
+My Key: "[{Special character place # |}" ### A # in string is allowed!
+"""
+
+    [<Literal>]
+    let JsonMappings ="""
+Mark McGwire: {hr: 65, avg: 0.278}
+Sammy Sosa: {
+    hr: 63,
+    avg: 0.288,
+}"""

package/fable_modules/YAMLicious.0.0.1/Library.fs.js

@@ -0,0 +1,7 @@
+import { PreprocessorElement } from "./YAMLiciousTypes.fs.js";
+import { ofArray } from "../fable-library-js.4.16.0/List.js";
+
+export const SequenceMappingsAST = new PreprocessorElement(0, [ofArray([new PreprocessorElement(2, ["-"]), new PreprocessorElement(1, [ofArray([new PreprocessorElement(2, ["My Key1: My Value1"]), new PreprocessorElement(2, ["My Key2: My Value2"]), new PreprocessorElement(2, ["My Key3: My Value3"])])]), new PreprocessorElement(2, ["-"]), new PreprocessorElement(1, [ofArray([new PreprocessorElement(2, ["My Key4: My Value4"]), new PreprocessorElement(2, ["My Key5: My Value5"]), new PreprocessorElement(2, ["My Key6: My Value6"])])])])]);
+
+export const StringReplaceClean = "\r\nMy Key: </1>\r\n";
+

package/fable_modules/YAMLicious.0.0.1/Persil.fs

@@ -0,0 +1,86 @@
+module YAMLicious.Persil
+
+open System
+open System.Collections.Generic
+open System.Text.RegularExpressions
+
+// Patterns:
+// https://regex101.com/r/V0AkIH/1
+
+[<Literal>]
+let StringMatchPattern = 
+    // (?<iscomment>#.*?)? checks if inside comment. if group is found do not parse as string
+    #if FABLE_COMPILER_PYTHON
+    "(?P<all>(?P<iscomment>#.*?)?\"(?P<stringValue>.+)\\\")"
+    #endif
+    #if FABLE_COMPILER_JAVASCRIPT || FABLE_COMPILER_TYPESCRIPT
+    "(?<all>(?<iscomment>#.*?)?\"(?<stringValue>.+)\")" // fable sets /gu for js regex (unicode, not required to escape ")
+    #endif
+    #if !FABLE_COMPILER
+    "(?<all>(?<iscomment>#.*?)?\\\"(?<stringValue>.+)\\\")" // \\\" --> escaped \"
+    #endif
+
+[<Literal>]
+let CommentMatchPattern = 
+    #if FABLE_COMPILER_PYTHON
+    "#(?P<comment>.*)"
+    #else
+    "#(?<comment>.*)"
+    #endif
+
+[<Literal>]
+let NewLineChar = '\n'
+
+let encodingCleanUp (s: string) =
+    //let newLineChars = "\f\u0085\u2028\u2029" |> Array.ofSeq
+    let s1 = s.Replace("\r\n", string NewLineChar)
+    //let mutable index = s1.IndexOfAny(newLineChars)
+    //if index = -1 then s1
+    //else
+    //    let sb = new System.Text.StringBuilder(s1)
+    //    while index <> -1 do
+    //        sb.Chars(index) <- replacementChar
+    //        index <- s1.IndexOfAny(newLineChars, index + 1)
+    //    sb.ToString()
+    s1
+
+let stringCleanUp (dict: Dictionary<int, string>) (s: string) =
+    let mutable n = 0
+    let regex = Regex(StringMatchPattern)
+    let matcheval = new MatchEvaluator(fun m ->
+        match m.Groups.["iscomment"].Success with
+        | true ->
+            m.Groups.["all"].Value
+        | false ->
+            let v = m.Groups.["stringValue"].Value
+            let currentN = n
+            n <- n + 1
+            dict.Add(currentN, v)
+            sprintf "<s f=%i/>" currentN
+    )
+    regex.Replace(s, matcheval)
+
+let commentCleanUp (dict: Dictionary<int, string>) (s: string) =
+    let mutable n = 0
+    let regex = Regex(CommentMatchPattern)
+    let matcheval = new MatchEvaluator(fun m ->
+        let v = m.Groups.["comment"].Value
+        let currentN = n
+        n <- n + 1
+        dict.Add(currentN, v)
+        sprintf "<c f=%i/>" currentN
+    )
+    regex.Replace(s, matcheval)
+
+let cut(yamlString: string) =
+    yamlString.Split([|NewLineChar|], StringSplitOptions.RemoveEmptyEntries)
+
+let pipeline (yamlString: string) =
+    let stringMap = new Dictionary<int, string>()
+    let commentMap = new Dictionary<int, string>()
+    let lines =
+        encodingCleanUp yamlString
+        |> stringCleanUp stringMap
+        |> commentCleanUp commentMap
+        |> cut
+    {|StringMap = stringMap; CommentMap = commentMap; Lines = lines|}

package/fable_modules/YAMLicious.0.0.1/Persil.fs.js

@@ -0,0 +1,49 @@
+import { split, printf, toText, replace } from "../fable-library-js.4.16.0/String.js";
+import { replace as replace_1 } from "../fable-library-js.4.16.0/RegExp.js";
+import { addToDict } from "../fable-library-js.4.16.0/MapUtil.js";
+
+export function encodingCleanUp(s) {
+    return replace(s, "\r\n", "\n");
+}
+
+export function stringCleanUp(dict, s) {
+    let n = 0;
+    return replace_1(/(?<all>(?<iscomment>#.*?)?"(?<stringValue>.+)")/gu, s, (m) => {
+        if ((m.groups && m.groups.iscomment) != null) {
+            return (m.groups && m.groups.all) || "";
+        }
+        else {
+            const v = (m.groups && m.groups.stringValue) || "";
+            const currentN = n | 0;
+            n = ((n + 1) | 0);
+            addToDict(dict, currentN, v);
+            return toText(printf("<s f=%i/>"))(currentN);
+        }
+    });
+}
+
+export function commentCleanUp(dict, s) {
+    let n = 0;
+    return replace_1(/#(?<comment>.*)/gu, s, (m) => {
+        const v = (m.groups && m.groups.comment) || "";
+        const currentN = n | 0;
+        n = ((n + 1) | 0);
+        addToDict(dict, currentN, v);
+        return toText(printf("<c f=%i/>"))(currentN);
+    });
+}
+
+export function cut(yamlString) {
+    return split(yamlString, ["\n"], void 0, 1);
+}
+
+export function pipeline(yamlString) {
+    const stringMap = new Map([]);
+    const commentMap = new Map([]);
+    return {
+        CommentMap: commentMap,
+        Lines: cut(commentCleanUp(commentMap, stringCleanUp(stringMap, encodingCleanUp(yamlString)))),
+        StringMap: stringMap,
+    };
+}
+

package/fable_modules/YAMLicious.0.0.1/Preprocessing.fs

@@ -0,0 +1,59 @@
+module YAMLicious.Preprocessing
+
+open System.Text
+open System.Collections.Generic
+open YAMLiciousTypes
+
+module ReadHelpers =
+    let indentLevel (line: string) =
+        line |> Seq.takeWhile (fun c -> c = ' ') |> Seq.length
+            
+let write(rootElement:PreprocessorElement, fconfig: (Config -> Config) option) =
+    let config = Config.init() |> fun config -> if fconfig.IsSome then fconfig.Value config else config
+    let sb = new StringBuilder()
+    let rec loop (current: PreprocessorElement) (sb: StringBuilder) (config: Config) =
+        match current with
+        | Line line ->
+            sb.AppendLine(config.WhitespaceString+line) |> ignore
+        | Intendation children ->
+            let nextConfig = {config with Level = config.Level + 1}
+            for child in children do
+                loop child sb nextConfig
+        | Level children ->
+            for child in children do
+                loop child sb config
+        | Nil -> ()
+    loop rootElement sb config
+    sb.ToString()
+
+let read(yamlStr: string) =
+    let content = Persil.pipeline yamlStr
+    let rec loop (lines: string list) (currentIntendation: int) (acc: PreprocessorElement list) =
+        match lines with
+        | [] -> acc
+        | line::rest ->
+            let lineEle = Line (line.Trim())
+            let nextIntendation = ReadHelpers.indentLevel line
+            if nextIntendation = currentIntendation then
+                loop rest currentIntendation (Line (line.Trim())::acc)
+            else
+                let nextLevelLines = rest |> List.takeWhile (fun l -> ReadHelpers.indentLevel l > currentIntendation)
+                let currentLevelLines = rest |> List.skipWhile (fun l -> ReadHelpers.indentLevel l > currentIntendation)
+                let otherChildren = loop nextLevelLines nextIntendation [] |> List.rev
+                let children = lineEle::otherChildren
+                loop currentLevelLines currentIntendation (Intendation children::acc)
+    let ast = 
+        loop (List.ofArray content.Lines) 0 [] 
+        |> List.rev
+        |> Level
+    {
+        AST = ast
+        StringMap = content.StringMap
+        CommentMap = content.CommentMap
+    }
+        
+let mkLine (line:string) = Line line
+
+let mklLevel (children: #seq<PreprocessorElement>) = List.ofSeq children |> Level
+
+let mkIntendation (children: #seq<PreprocessorElement>) = List.ofSeq children |> Intendation