@nfdi4plants/arctrl 2.0.1 → 2.1.0-alpha.2

package/fable_modules/DynamicObj.4.0.0/DynamicObj.fs.js

@@ -0,0 +1,166 @@
+import { tryGetStaticPropertyInfo } from "./ReflectionUtils.fs.js";
+import { getPropertyHelpers, tryGetDynamicPropertyHelper } from "./FableJS.fs.js";
+import { defaultArg, value as value_1, map } from "../fable-library-js.4.22.0/Option.js";
+import { sortBy, iterate, map as map_1, choose, filter } from "../fable-library-js.4.22.0/Seq.js";
+import { boxHashKeyValSeq } from "./HashCodes.fs.js";
+import { safeHash, comparePrimitives } from "../fable-library-js.4.22.0/Util.js";
+import { class_type } from "../fable-library-js.4.22.0/Reflection.js";
+
+export class DynamicObj {
+    constructor() {
+        this.properties = (new Map([]));
+    }
+    get Properties() {
+        const this$ = this;
+        return this$.properties;
+    }
+    set Properties(value) {
+        const this$ = this;
+        this$.properties = value;
+    }
+    static ofDict(dynamicProperties) {
+        const obj = new DynamicObj();
+        obj.Properties = dynamicProperties;
+        return obj;
+    }
+    TryGetStaticPropertyHelper(propertyName) {
+        const this$ = this;
+        return tryGetStaticPropertyInfo(this$, propertyName);
+    }
+    TryGetDynamicPropertyHelper(propertyName) {
+        const this$ = this;
+        return tryGetDynamicPropertyHelper(this$, propertyName);
+    }
+    TryGetPropertyHelper(propertyName) {
+        const this$ = this;
+        const matchValue = this$.TryGetStaticPropertyHelper(propertyName);
+        return (matchValue == null) ? this$.TryGetDynamicPropertyHelper(propertyName) : matchValue;
+    }
+    TryGetPropertyValue(propertyName) {
+        const this$ = this;
+        return map((pi) => pi.GetValue(this$), this$.TryGetPropertyHelper(propertyName));
+    }
+    GetPropertyValue(propertyName) {
+        const this$ = this;
+        const matchValue = this$.TryGetPropertyValue(propertyName);
+        if (matchValue == null) {
+            throw new Error(`No dynamic or static property "${propertyName}" does exist on object.`);
+        }
+        else {
+            return value_1(matchValue);
+        }
+    }
+    SetProperty(propertyName, propertyValue) {
+        const this$ = this;
+        const matchValue = this$.TryGetStaticPropertyHelper(propertyName);
+        if (matchValue == null) {
+            this$[propertyName] = propertyValue;
+        }
+        else {
+            const pi = matchValue;
+            if (pi.IsMutable) {
+                pi.SetValue(this$, propertyValue);
+            }
+            else {
+                throw new Error(`Cannot set value for static, immutable property "${propertyName}"`);
+            }
+        }
+    }
+    RemoveProperty(propertyName) {
+        const this$ = this;
+        const matchValue = this$.TryGetPropertyHelper(propertyName);
+        if (matchValue == null) {
+            return false;
+        }
+        else if (matchValue.IsMutable) {
+            const pi_1 = matchValue;
+            pi_1.RemoveValue(this$);
+            return true;
+        }
+        else {
+            throw new Error(`Cannot remove value for static, immutable property "${propertyName}"`);
+        }
+    }
+    GetPropertyHelpers(includeInstanceProperties) {
+        const this$ = this;
+        return filter((p) => (p.Name.toLocaleLowerCase() !== "properties"), filter((pd) => {
+            if (includeInstanceProperties) {
+                return true;
+            }
+            else {
+                return pd.IsDynamic;
+            }
+        }, getPropertyHelpers(this$)));
+    }
+    GetProperties(includeInstanceProperties) {
+        const this$ = this;
+        return choose((kv) => {
+            if (kv.Name !== "properties") {
+                return [kv.Name, kv.GetValue(this$)];
+            }
+            else {
+                return undefined;
+            }
+        }, this$.GetPropertyHelpers(includeInstanceProperties));
+    }
+    GetPropertyNames(includeInstanceProperties) {
+        const this$ = this;
+        return map_1((kv) => kv[0], this$.GetProperties(includeInstanceProperties));
+    }
+    CopyDynamicPropertiesTo(target, overWrite) {
+        const this$ = this;
+        const overWrite_1 = defaultArg(overWrite, false);
+        iterate((kv) => {
+            let pi;
+            const matchValue = target.TryGetPropertyHelper(kv[0]);
+            if (matchValue == null) {
+                target.SetProperty(kv[0], kv[1]);
+            }
+            else if ((pi = matchValue, overWrite_1)) {
+                const pi_1 = matchValue;
+                pi_1.SetValue(target, kv[1]);
+            }
+            else {
+                throw new Error(`Property "${kv[0]}" already exists on target object and overWrite was not set to true.`);
+            }
+        }, this$.GetProperties(false));
+    }
+    CopyDynamicProperties() {
+        const this$ = this;
+        const target = new DynamicObj();
+        this$.CopyDynamicPropertiesTo(target);
+        return target;
+    }
+    static op_Dynamic(lookup, name) {
+        const matchValue = lookup.TryGetPropertyValue(name);
+        if (matchValue == null) {
+            throw new Error();
+        }
+        else {
+            return value_1(matchValue);
+        }
+    }
+    static op_DynamicAssignment(lookup, name, value) {
+        lookup.SetProperty(name, value);
+    }
+    GetHashCode() {
+        const this$ = this;
+        return boxHashKeyValSeq(sortBy((pair) => pair[0], this$.GetProperties(true), {
+            Compare: comparePrimitives,
+        })) | 0;
+    }
+    Equals(o) {
+        let other;
+        const this$ = this;
+        return (o instanceof DynamicObj) && ((other = o, safeHash(this$) === safeHash(other)));
+    }
+}
+
+export function DynamicObj_$reflection() {
+    return class_type("DynamicObj.DynamicObj", undefined, DynamicObj);
+}
+
+export function DynamicObj_$ctor() {
+    return new DynamicObj();
+}
+

package/fable_modules/DynamicObj.4.0.0/FableJS.fs

@@ -0,0 +1,162 @@
+namespace DynamicObj
+
+
+#if FABLE_COMPILER_JAVASCRIPT || FABLE_COMPILER_TYPESCRIPT || !FABLE_COMPILER
+
+open Fable.Core
+
+module FableJS =
+    
+    module PropertyDescriptor = 
+        
+        [<Emit("$0[$1]")>]
+        let tryGetPropertyValue (o:obj) (propName:string) : obj option =
+            jsNative
+
+        let tryGetIsWritable (o:obj) : bool option =
+            tryGetPropertyValue o "writable"
+            |> Option.map (fun v -> v :?> bool)
+
+        let containsGetter (o:obj) : bool =
+            match tryGetPropertyValue o "get" with
+            | Some _ -> true
+            | None -> false
+
+        let containsSetter (o:obj) : bool =
+            match tryGetPropertyValue o "set" with
+            | Some _ -> true
+            | None -> false
+
+        let isWritable (o:obj) : bool =
+            match tryGetIsWritable o with
+            | Some v -> v
+            | None -> containsSetter o
+
+        [<Emit("typeof $0 === 'function'")>]
+        let valueIsFunction (o:obj) : bool =
+            jsNative
+
+        let isFunction (o:obj) : bool =
+            match tryGetPropertyValue o "value" with
+            | Some v -> valueIsFunction v
+            | None -> false
+
+    [<Emit("Object.getOwnPropertyNames($0)")>]
+    let getOwnPropertyNames (o:obj) : string [] =
+        jsNative
+
+    [<Emit("Object.getPrototypeOf($0)")>]
+    let getPrototype (o:obj) : obj =
+        jsNative
+
+    let getStaticPropertyNames (o:obj) =
+        getPrototype o
+        |> getOwnPropertyNames
+        |> Array.filter (fun n -> n <> "constructor")
+
+    [<Emit("$0[$1] = $2")>]
+    let setPropertyValue (o:obj) (propName:string) (value:obj) =    
+        jsNative
+
+    let createSetter (propName:string) =
+        fun (o:obj) (value:obj) -> 
+         setPropertyValue o propName value
+
+    let removeStaticPropertyValue (o:obj) (propName:string) =
+        setPropertyValue o propName null
+
+    [<Emit("delete $0[$1]")>]
+    let deleteDynamicPropertyValue (o:obj) (propName:string) =
+        jsNative
+
+    let createRemover (propName:string) (isStatic : bool) =
+        if isStatic then
+            fun (o:obj) -> 
+                removeStaticPropertyValue o propName
+        else
+            fun (o:obj) -> 
+                deleteDynamicPropertyValue o propName
+
+
+    [<Emit("$0[$1]")>]
+    let getPropertyValue (o:obj) (propName:string) =
+        jsNative
+
+    let createGetter (propName:string) =
+        fun (o:obj) -> 
+            getPropertyValue o propName
+
+    [<Emit("Object.getOwnPropertyDescriptor($0, $1)")>]
+    let tryGetPropertyDescriptor (o:obj) (propName:string) : obj option =
+        jsNative
+
+    let tryGetStaticPropertyDescriptor (o:obj) (propName:string) : obj option=
+        tryGetPropertyDescriptor (getPrototype o) propName
+
+    let tryStaticPropertyHelperFromDescriptor (pd:obj) (name:string) : PropertyHelper option =
+        let isWritable = PropertyDescriptor.isWritable pd
+        if PropertyDescriptor.isFunction pd then 
+            None
+        else 
+            {
+                Name = name
+                IsStatic = true
+                IsDynamic = false
+                IsMutable = isWritable
+                IsImmutable = not isWritable
+                GetValue = createGetter name
+                SetValue = createSetter name
+                RemoveValue = createRemover name true
+            }     
+            |> Some
+        
+    let tryGetStaticPropertyHelper (o:obj) (propName:string) : PropertyHelper option =
+        tryGetStaticPropertyDescriptor o propName
+        |> Option.bind (fun pd -> tryStaticPropertyHelperFromDescriptor pd propName)
+        
+    let getStaticPropertyHelpers (o:obj) : PropertyHelper [] =
+        getStaticPropertyNames o
+        |> Array.choose (tryGetStaticPropertyHelper o)
+
+    let tryGetDynamicPropertyDescriptor (o:obj) (propName:string) : obj option =
+        tryGetPropertyDescriptor o propName
+
+    let transpiledPropertyRegex = "^[a-zA-Z]+@[0-9]+$"
+
+    let isTranspiledPropertyHelper (propertyName : string) =
+        System.Text.RegularExpressions.Regex.IsMatch(propertyName, transpiledPropertyRegex)
+
+    let tryDynamicPropertyHelperFromDescriptor (pd:obj) (name:string) : PropertyHelper option =
+        if PropertyDescriptor.isFunction pd || isTranspiledPropertyHelper name then 
+                None
+        else 
+            {
+                Name = name
+                IsStatic = false
+                IsDynamic = true
+                IsMutable = true
+                IsImmutable = false
+                GetValue = createGetter name
+                SetValue = createSetter name
+                RemoveValue = createRemover name false
+            }     
+            |> Some
+
+    let tryGetDynamicPropertyHelper (o:obj) (propName:string) : PropertyHelper option =
+        tryGetDynamicPropertyDescriptor o propName
+        |> Option.bind (fun pd -> tryDynamicPropertyHelperFromDescriptor pd propName)
+
+    let getDynamicPropertyHelpers (o:obj) : PropertyHelper [] =
+        getOwnPropertyNames o
+        |> Array.choose (tryGetDynamicPropertyHelper o)
+
+    let getPropertyHelpers (o:obj) =
+        getDynamicPropertyHelpers o
+        |> Array.append (getStaticPropertyHelpers o)
+
+    let getPropertyNames (o:obj) =
+        getPropertyHelpers o 
+        |> Array.map (fun h -> h.Name)
+
+
+#endif

package/fable_modules/DynamicObj.4.0.0/FableJS.fs.js

@@ -0,0 +1,141 @@
+import { bind, value as value_1, map } from "../fable-library-js.4.22.0/Option.js";
+import { defaultOf } from "../fable-library-js.4.22.0/Util.js";
+import { PropertyHelper } from "./PropertyHelper.fs.js";
+import { map as map_1, append, choose } from "../fable-library-js.4.22.0/Array.js";
+import { create, isMatch } from "../fable-library-js.4.22.0/RegExp.js";
+
+export function PropertyDescriptor_tryGetIsWritable(o) {
+    return map((v) => v, o["writable"]);
+}
+
+export function PropertyDescriptor_containsGetter(o) {
+    const matchValue = o["get"];
+    if (matchValue == null) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+
+export function PropertyDescriptor_containsSetter(o) {
+    const matchValue = o["set"];
+    if (matchValue == null) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+
+export function PropertyDescriptor_isWritable(o) {
+    const matchValue = PropertyDescriptor_tryGetIsWritable(o);
+    if (matchValue == null) {
+        return PropertyDescriptor_containsSetter(o);
+    }
+    else {
+        return matchValue;
+    }
+}
+
+export function PropertyDescriptor_isFunction(o) {
+    const matchValue = o["value"];
+    if (matchValue == null) {
+        return false;
+    }
+    else {
+        const v = value_1(matchValue);
+        return typeof v === 'function';
+    }
+}
+
+export function getStaticPropertyNames(o) {
+    let array;
+    const o_1 = Object.getPrototypeOf(o);
+    array = (Object.getOwnPropertyNames(o_1));
+    return array.filter((n) => (n !== "constructor"));
+}
+
+export function createSetter(propName, o, value) {
+    return o[propName] = value;
+}
+
+export function removeStaticPropertyValue(o, propName) {
+    return o[propName] = defaultOf();
+}
+
+export function createRemover(propName, isStatic) {
+    if (isStatic) {
+        return (o) => removeStaticPropertyValue(o, propName);
+    }
+    else {
+        return (o_1) => (delete o_1[propName]);
+    }
+}
+
+export function createGetter(propName, o) {
+    return o[propName];
+}
+
+export function tryGetStaticPropertyDescriptor(o, propName) {
+    return Object.getOwnPropertyDescriptor((Object.getPrototypeOf(o)), propName);
+}
+
+export function tryStaticPropertyHelperFromDescriptor(pd, name) {
+    const isWritable = PropertyDescriptor_isWritable(pd);
+    if (PropertyDescriptor_isFunction(pd)) {
+        return undefined;
+    }
+    else {
+        return new PropertyHelper(name, true, false, isWritable, !isWritable, (o) => createGetter(name, o), (o_1, value) => {
+            createSetter(name, o_1, value);
+        }, createRemover(name, true));
+    }
+}
+
+export function tryGetStaticPropertyHelper(o, propName) {
+    return bind((pd) => tryStaticPropertyHelperFromDescriptor(pd, propName), tryGetStaticPropertyDescriptor(o, propName));
+}
+
+export function getStaticPropertyHelpers(o) {
+    return choose((propName) => tryGetStaticPropertyHelper(o, propName), getStaticPropertyNames(o));
+}
+
+export function tryGetDynamicPropertyDescriptor(o, propName) {
+    return Object.getOwnPropertyDescriptor(o, propName);
+}
+
+export const transpiledPropertyRegex = "^[a-zA-Z]+@[0-9]+$";
+
+export function isTranspiledPropertyHelper(propertyName) {
+    return isMatch(create(transpiledPropertyRegex), propertyName);
+}
+
+export function tryDynamicPropertyHelperFromDescriptor(pd, name) {
+    if (PropertyDescriptor_isFunction(pd) ? true : isTranspiledPropertyHelper(name)) {
+        return undefined;
+    }
+    else {
+        return new PropertyHelper(name, false, true, true, false, (o) => createGetter(name, o), (o_1, value) => {
+            createSetter(name, o_1, value);
+        }, createRemover(name, false));
+    }
+}
+
+export function tryGetDynamicPropertyHelper(o, propName) {
+    return bind((pd) => tryDynamicPropertyHelperFromDescriptor(pd, propName), tryGetDynamicPropertyDescriptor(o, propName));
+}
+
+export function getDynamicPropertyHelpers(o) {
+    return choose((propName) => tryGetDynamicPropertyHelper(o, propName), Object.getOwnPropertyNames(o));
+}
+
+export function getPropertyHelpers(o) {
+    const array_1 = getDynamicPropertyHelpers(o);
+    return append(getStaticPropertyHelpers(o), array_1);
+}
+
+export function getPropertyNames(o) {
+    return map_1((h) => h.Name, getPropertyHelpers(o));
+}
+

package/fable_modules/DynamicObj.4.0.0/FablePy.fs

@@ -0,0 +1,215 @@
+namespace DynamicObj
+
+
+#if FABLE_COMPILER_PYTHON || !FABLE_COMPILER
+
+open Fable.Core
+open System.Collections.Generic
+
+module FablePy =
+    
+    module Dictionary = 
+        
+        let ofSeq (s:seq<KeyValuePair<_,_>>) =
+            let d = new System.Collections.Generic.Dictionary<_,_>()
+            s |> Seq.iter (fun kv -> d.Add(kv.Key, kv.Value))
+            d
+
+        let choose (f: 'T -> 'U option) (d:System.Collections.Generic.Dictionary<_,'T>) =
+            let nd = new System.Collections.Generic.Dictionary<_,'U>()
+            for kv in d do
+                match f kv.Value with
+                | Some v -> nd.Add(kv.Key, v)
+                | None -> ()
+            nd
+
+    type PropertyObject = 
+        abstract fget : obj
+        abstract fset : obj
+
+    module PropertyObject = 
+        
+        [<Emit("$0.fget")>]
+        let tryGetGetter (o:PropertyObject) : (obj -> obj) option =
+            nativeOnly
+
+        [<Emit("$0.fset")>]
+        let tryGetSetter (o:PropertyObject) : (obj -> obj -> unit) option =
+            nativeOnly
+
+        let getGetter (o : PropertyObject) : obj -> obj =
+            match tryGetGetter o with
+            | Some f -> f
+            | None -> fun o -> failwith ("Property does not contain getter")
+
+        let getSetter (o:PropertyObject) : obj -> obj -> unit =
+            match tryGetSetter o with
+            | Some f -> f
+            | None -> fun s o -> failwith ("Property does not contain setter")
+
+        let containsGetter (o:PropertyObject) : bool =
+            match tryGetGetter o with
+            | Some _ -> true
+            | None -> false
+
+        let containsSetter (o:PropertyObject) : bool =
+            match tryGetSetter o with
+            | Some _ -> true
+            | None -> false
+
+        let isWritable (o:PropertyObject) : bool =
+            containsSetter o
+
+        [<Emit("isinstance($0, property)")>]
+        let isProperty (o:obj) : bool =
+            nativeOnly
+
+        let tryProperty (o:obj) : PropertyObject option =
+            if isProperty o then
+                Some (o :?> PropertyObject)
+            else
+                None
+
+    [<Emit("getattr($0,$1)")>]
+    let getPropertyValue (o:obj) (propName:string) =
+        nativeOnly
+
+    let createGetter (propName:string) =
+        fun (o:obj) -> 
+            getPropertyValue o propName
+
+    [<Emit("setattr($0,$1,$2)")>]
+    let setPropertyValue (o:obj) (propName:string) (value:obj) : unit =    
+        nativeOnly
+
+    let createSetter (propName:string) =
+        fun (o:obj) (value:obj) -> 
+         setPropertyValue o propName value
+
+
+    [<Emit("vars($0).items()")>]
+    let getOwnMemberObjects (o:obj) : Dictionary<string,obj> =
+        nativeOnly
+
+    [<Emit("$0.__class__")>]
+    let getClass (o:obj) : obj =
+        nativeOnly
+
+    let getStaticPropertyObjects (o:obj) : Dictionary<string,PropertyObject> =
+        getClass o
+        |> getOwnMemberObjects
+        |> Dictionary.choose PropertyObject.tryProperty
+
+    let removeStaticPropertyValue (o:obj) (propName:string) =
+        setPropertyValue o propName null
+
+    [<Emit("delattr($0,$1)")>]
+    let deleteDynamicPropertyValue (o:obj) (propName:string) =
+        nativeOnly
+
+    let createRemover (propName:string) (isStatic : bool) =
+        if isStatic then
+            fun (o:obj) -> 
+                removeStaticPropertyValue o propName
+        else
+            fun (o:obj) -> 
+                deleteDynamicPropertyValue o propName
+
+
+
+    [<Emit("$0.__dict__.get($1)")>]
+    let getMemberObject (o:obj) (propName:string) =
+        nativeOnly
+
+    let tryGetPropertyObject (o:obj) (propName:string) : PropertyObject option =
+        match PropertyObject.tryProperty (getMemberObject o propName) with
+        | Some po -> Some po
+        | None -> None
+
+    let tryGetDynamicPropertyHelper (o:obj) (propName:string) : PropertyHelper option =
+        match getMemberObject o propName with
+        | Some _ -> 
+            Some {
+                Name = propName
+                IsStatic = false
+                IsDynamic = true
+                IsMutable = true
+                IsImmutable = false
+                GetValue = createGetter propName
+                SetValue = createSetter propName
+                RemoveValue = fun o -> deleteDynamicPropertyValue o propName
+            }
+        | None -> None
+
+    let tryGetStaticPropertyHelper (o:obj) (propName:string) : PropertyHelper option =
+        match tryGetPropertyObject (getClass o) propName with
+        | Some po -> 
+            let isWritable = PropertyObject.isWritable po
+            Some {
+                Name = propName
+                IsStatic = true
+                IsDynamic = false
+                IsMutable = isWritable
+                IsImmutable = not isWritable
+                GetValue = createGetter propName
+                SetValue = createSetter propName
+                RemoveValue = fun o -> removeStaticPropertyValue o propName
+            }
+         | None -> None
+
+    let transpiledPropertyRegex = "^([a-zA-Z]+_)+[0-9]+$"
+
+    let isTranspiledPropertyHelper (propertyName : string) =
+        System.Text.RegularExpressions.Regex.IsMatch(propertyName, transpiledPropertyRegex)
+
+
+    let getDynamicPropertyHelpers (o:obj) : PropertyHelper [] =
+        getOwnMemberObjects o
+        |> Seq.choose (fun kv -> 
+            let n = kv.Key
+            if isTranspiledPropertyHelper n then 
+                None
+            else
+                {
+                    Name = n
+                    IsStatic = false
+                    IsDynamic = true
+                    IsMutable = true
+                    IsImmutable = false
+                    GetValue = createGetter n
+                    SetValue = createSetter n
+                    RemoveValue = fun o -> deleteDynamicPropertyValue o n
+                }
+                |> Some
+        )
+        |> Seq.toArray
+
+
+    let getStaticPropertyHelpers (o:obj) : PropertyHelper [] =
+        getStaticPropertyObjects o
+        |> Seq.map (fun kv -> 
+            let n = kv.Key
+            let po = kv.Value
+            {
+                Name = n
+                IsStatic = true
+                IsDynamic = false
+                IsMutable = PropertyObject.isWritable po
+                IsImmutable = not (PropertyObject.isWritable po)
+                GetValue = createGetter n
+                SetValue = createSetter n
+                RemoveValue = fun o -> removeStaticPropertyValue o n
+            }
+        )
+        |> Seq.toArray
+
+    let getPropertyHelpers (o:obj) =
+        getDynamicPropertyHelpers o
+        |> Array.append (getStaticPropertyHelpers o)
+
+    let getPropertyNames (o:obj) =
+        getPropertyHelpers o 
+        |> Array.map (fun h -> h.Name)
+
+
+#endif