@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/fable_modules/YAMLicious.0.0.3/Encode.fs

@@ -1,148 +0,0 @@
-/// 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.3/Encode.fs.js

@@ -1,74 +0,0 @@
-import { Config, YAMLElement, YAMLContent_create_27AED5E3 } from "./YAMLiciousTypes.fs.js";
-import { int32ToString } from "../fable-library-js.4.24.0/Util.js";
-import { toString } from "../fable-library-js.4.24.0/Types.js";
-import { toString as toString_1 } from "../fable-library-js.4.24.0/Date.js";
-import { ofArray, map as map_1, ofSeq } from "../fable-library-js.4.24.0/List.js";
-import { map } from "../fable-library-js.4.24.0/Seq.js";
-import { value as value_1 } from "../fable-library-js.4.24.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.3/Interop/JsInterop.fs

@@ -1,14 +0,0 @@
-[<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.3/Interop/JsInterop.fs.js

@@ -1,11 +0,0 @@
-
-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.3/Interop/PyInterop.fs

@@ -1,9 +0,0 @@
-[<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.3/Library.fs

@@ -1,138 +0,0 @@
-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.3/Library.fs.js

@@ -1,7 +0,0 @@
-import { PreprocessorElement } from "./YAMLiciousTypes.fs.js";
-import { ofArray } from "../fable-library-js.4.24.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.3/Persil.fs

@@ -1,86 +0,0 @@
-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.3/Persil.fs.js

@@ -1,49 +0,0 @@
-import { split, printf, toText, replace } from "../fable-library-js.4.24.0/String.js";
-import { replace as replace_1 } from "../fable-library-js.4.24.0/RegExp.js";
-import { addToDict } from "../fable-library-js.4.24.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"], undefined, 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.3/Preprocessing.fs

@@ -1,59 +0,0 @@
-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