@nfdi4plants/arctrl 3.1.1 → 3.2.0

package/dist/ts/ts/fable_modules/DynamicObj.8.0.0/DynamicObj.fs.js

@@ -0,0 +1,515 @@
+import { defaultOf, Exception, safeHash, comparePrimitives, isIterable, getEnumerator, isArrayLike, disposeSafe, structuralHash, equals } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { tryGetStaticPropertyInfo, getStaticProperties } from './ReflectionUtils.fs.js';
+import { value, some, defaultArg } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { PropertyHelper } from './PropertyHelper.fs.js';
+import { tryGetValue, getItemFromDict, addToDict } from '../../../node_modules/@fable-org/fable-library-ts/MapUtil.js';
+import { FSharpRef } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { concat } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+import { filter, toList, delay, append, empty, map, choose, iterate, sortBy, enumerateWhile, singleton } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
+import { boxHashKeyValSeqBy, hash, mergeHashes } from './HashCodes.fs.js';
+import { isEmpty, reduce, FSharpList } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { Dictionary } from '../../../node_modules/@fable-org/fable-library-ts/MutableMap.js';
+import '../../../node_modules/@fable-org/fable-library-ts/Decimal.js';
+import { Big } from '../../../node_modules/@fable-org/fable-library-ts/lib/big.js';
+
+class DynamicObj {
+  constructor() {
+    this.properties = /* @__PURE__ */ new Map([]);
+  }
+  /**
+   * A dictionary of dynamic boxed properties
+   */
+  get Properties() {
+    const this$ = this;
+    return this$.properties;
+  }
+  /**
+   * A dictionary of dynamic boxed properties
+   */
+  set Properties(value) {
+    const this$ = this;
+    this$.properties = value;
+  }
+  /**
+   * Creates a new DynamicObj from a Dictionary containing dynamic properties.
+   */
+  static ofDict(dynamicProperties) {
+    const obj = new DynamicObj();
+    obj.Properties = dynamicProperties;
+    return obj;
+  }
+  /**
+   * Returns Some(PropertyHelper) if a static property with the given name exists, otherwise None.
+   */
+  TryGetStaticPropertyHelper(propertyName) {
+    const this$ = this;
+    return tryGetStaticPropertyInfo(this$, propertyName);
+  }
+  /**
+   * Returns Some(PropertyHelper) if a dynamic property with the given name exists, otherwise None.
+   */
+  TryGetDynamicPropertyHelper(propertyName) {
+    let outArg = void 0;
+    const this$ = this;
+    return (outArg = defaultOf(), [tryGetValue(this$.properties, propertyName, new FSharpRef(() => outArg, (v) => {
+      outArg = v;
+    })), outArg])[0] ? new PropertyHelper(propertyName, false, true, true, false, (o) => getItemFromDict(this$.properties, propertyName), (o_1, v_1) => {
+      this$.properties.set(propertyName, v_1);
+    }, (o_2) => {
+      this$.properties.delete(propertyName);
+    }) : void 0;
+  }
+  /**
+   * Returns Some(PropertyHelper) if a property (static or dynamic) with the given name exists, otherwise None.
+   */
+  TryGetPropertyHelper(propertyName) {
+    const this$ = this;
+    const matchValue = this$.TryGetStaticPropertyHelper(propertyName);
+    return matchValue == null ? this$.TryGetDynamicPropertyHelper(propertyName) : value(matchValue);
+  }
+  /**
+   * Returns Some(boxed property value) if a dynamic (or static) property with the given name exists, otherwise None.
+   */
+  TryGetPropertyValue(propertyName) {
+    const this$ = this;
+    const option_1 = this$.TryGetPropertyHelper(propertyName);
+    return option_1 != null ? some(value(option_1).GetValue(this$)) : void 0;
+  }
+  /**
+   * Returns the boxed property value of the dynamic (or static) property with the given name.
+   */
+  GetPropertyValue(propertyName) {
+    const this$ = this;
+    const matchValue = this$.TryGetPropertyValue(propertyName);
+    if (matchValue == null) {
+      throw new Exception(concat('No dynamic or static property "', propertyName, '" does exist on object.'));
+    } else {
+      return value(matchValue);
+    }
+  }
+  /**
+   * Sets the dynamic (or static) property value with the given name, creating a new dynamic property if none exists.
+   */
+  SetProperty(propertyName, propertyValue) {
+    let outArg = void 0;
+    const this$ = this;
+    const matchValue = this$.TryGetStaticPropertyHelper(propertyName);
+    if (matchValue == null) {
+      if ((outArg = defaultOf(), [tryGetValue(this$.properties, propertyName, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg])[0]) {
+        this$.properties.set(propertyName, propertyValue);
+      } else {
+        addToDict(this$.properties, propertyName, propertyValue);
+      }
+    } else {
+      const pi = value(matchValue);
+      if (pi.IsMutable) {
+        pi.SetValue(this$, propertyValue);
+      } else {
+        throw new Exception(concat('Cannot set value for static, immutable property "', propertyName, '"'));
+      }
+    }
+  }
+  /**
+   * Removes any dynamic property with the given name from the input DynamicObj.
+   * If the property is static and mutable, it will be set to null.
+   * Static immutable properties cannot be removed.
+   */
+  RemoveProperty(propertyName) {
+    const this$ = this;
+    const matchValue = this$.TryGetPropertyHelper(propertyName);
+    if (matchValue == null) {
+      return false;
+    } else if (value(matchValue).IsMutable) {
+      const pi_1 = value(matchValue);
+      pi_1.RemoveValue(this$);
+      return true;
+    } else {
+      throw new Exception(concat('Cannot remove value for static, immutable property "', propertyName, '"'));
+    }
+  }
+  /**
+   * Returns PropertyHelpers for all dynamic properties of the DynamicObj.
+   * 
+   * When includeInstanceProperties is set to true, instance properties (= 'static' properties on the class) are included in the result.
+   */
+  GetPropertyHelpers(includeInstanceProperties) {
+    const this$ = this;
+    return filter((p) => p.Name.toLocaleLowerCase() !== "properties", toList(delay(() => append(includeInstanceProperties ? getStaticProperties(this$) : empty(), delay(() => map((key) => new PropertyHelper(key, false, true, true, false, (o) => getItemFromDict(this$.properties, key), (o_1, v) => {
+      this$.properties.set(key, v);
+    }, (o_2) => {
+      this$.properties.delete(key);
+    }), this$.properties.keys()))))));
+  }
+  /**
+   * Returns a sequence of all dynamic properties as a key value pair of the property names and the boxed property values.
+   * 
+   * When includeInstanceProperties is set to true, instance properties (= 'static' properties on the class) are included in the result.
+   */
+  GetProperties(includeInstanceProperties) {
+    const this$ = this;
+    return choose((kv) => {
+      if (kv.Name !== "properties") {
+        return [kv.Name, kv.GetValue(this$)];
+      } else {
+        return void 0;
+      }
+    }, this$.GetPropertyHelpers(includeInstanceProperties));
+  }
+  /**
+   * Returns a sequence of all dynamic property names.
+   * 
+   * When includeInstanceProperties is set to true, instance properties (= 'static' properties on the class) are included in the result.
+   */
+  GetPropertyNames(includeInstanceProperties) {
+    const this$ = this;
+    return map((kv) => kv[0], this$.GetProperties(includeInstanceProperties));
+  }
+  /**
+   * Copies all dynamic properties to a target `DynamicObj` instance without trying to prevent reference equality.
+   * 
+   * Note that this function does not attempt to do any deep copying.
+   * The dynamic properties of the source will be copied as references to the target.
+   * If any of those properties are mutable or themselves DynamicObj instances, changes to the properties on the source will be reflected in the target.
+   * 
+   * If overWrite is set to true, existing properties on the target object will be overwritten.
+   */
+  ShallowCopyDynamicPropertiesTo(target, overWrite) {
+    const this$ = this;
+    const overWrite_1 = defaultArg(overWrite, false);
+    iterate((kv) => {
+      const matchValue = target.TryGetPropertyHelper(kv[0]);
+      if (matchValue == null) {
+        target.SetProperty(kv[0], kv[1]);
+      } else if (value(matchValue), overWrite_1) {
+        const pi_1 = value(matchValue);
+        pi_1.SetValue(target, kv[1]);
+      }
+    }, this$.GetProperties(false));
+  }
+  /**
+   * Copies all dynamic properties to a new `DynamicObj` instance without trying to prevent reference equality.
+   * 
+   * Note that this function does not attempt to do any deep copying.
+   * The dynamic properties of the source will be copied as references to the target.
+   * If any of those properties are mutable or themselves DynamicObj instances, changes to the properties on the source will be reflected in the target.
+   */
+  ShallowCopyDynamicProperties() {
+    const this$ = this;
+    const target = new DynamicObj();
+    this$.ShallowCopyDynamicPropertiesTo(target, true);
+    return target;
+  }
+  /**
+   * Recursively deep copies **all** (static and dynamic) properties to a **target** `DynamicObj` instance (or derived class). Reinstantiation - and therefore prevention of reference equality - is possible for `DynamicObj`, `array|list|ResizeArray<DynamicObj>`, and classes implementing `System.Icloneable`
+   * 
+   * As many properties as possible are re-instantiated as new objects, meaning the
+   * copy has as little reference equal properties as possible.
+   * 
+   * The nature of DynamicObj however means that it is impossible to reliably deep copy all properties, as
+   * their type is not known on runtime and the contructors of the types are not known.
+   * 
+   * The following cases are handled (in this precedence):
+   * 
+   * - Basic F# types (`bool`, `byte`, `sbyte`, `int16`, `uint16`, `int`, `uint`, `int64`, `uint64`, `nativeint`, `unativeint`, `float`, `float32`, `char`, `string`, `unit`, `decimal`)
+   * 
+   * - `ResizeArrays` and `Dictionaries` containing any combination of basic F# types
+   * 
+   * - `Dictionaries` containing `DynamicObj` as keys or values in any combination with `DynamicObj` or basic F# types as keys or values
+   * 
+   * - `array<DynamicObj>`, `list<DynamicObj>`, `ResizeArray<DynamicObj>`: These collections of DynamicObj are copied as a new collection with recursively deep copied elements.
+   * 
+   * - `System.ICloneable`: If the property implements `ICloneable`, the `Clone()` method is called on the property.
+   * 
+   * - `DynamicObj` (and derived classes): properties that are themselves `DynamicObj` instances are deep copied recursively.
+   * if a derived class has static properties (e.g. instance properties), these can be copied as dynamic properties on the new instance or ignored.
+   * 
+   * Note on Classes that inherit from `DynamicObj`:
+   * 
+   * Classes that inherit from DynamicObj will match the `DynamicObj` typecheck if they do not implement `ICloneable`.
+   * The deep copied instances will be cast to `DynamicObj` with deep copied dynamic properties. Staic/instance properties can be copied as dynamic properties on the new instance or be ignored.
+   * It should be possible to 'recover' the original type by checking if the needed properties exist as dynamic properties,
+   * and then passing them to the class constructor if needed.
+   */
+  DeepCopyPropertiesTo(target, overWrite, includeInstanceProperties) {
+    const this$ = this;
+    const overWrite_1 = defaultArg(overWrite, false);
+    const includeInstanceProperties_1 = defaultArg(includeInstanceProperties, true);
+    iterate((kv) => {
+      const matchValue = target.TryGetPropertyHelper(kv[0]);
+      if (matchValue == null) {
+        target.SetProperty(kv[0], CopyUtils_tryDeepCopyObj_75B3D832(kv[1]));
+      } else if (value(matchValue), overWrite_1) {
+        const pi_1 = value(matchValue);
+        pi_1.SetValue(target, CopyUtils_tryDeepCopyObj_75B3D832(kv[1]));
+      }
+    }, this$.GetProperties(includeInstanceProperties_1));
+  }
+  /**
+   * Recursively deep copy a `DynamicObj` instance (or derived class) with **all** (static and dynamic) properties. Reinstantiation - and therefore prevention of reference equality - is possible for `DynamicObj`, `array|list|ResizeArray<DynamicObj>`, and classes implementing `System.Icloneable`
+   * 
+   * On the deep copy, as many properties as possible are re-instantiated as new objects, meaning the
+   * copy has as little reference equal properties as possible.
+   * 
+   * The nature of DynamicObj however means that it is impossible to reliably deep copy all properties, as
+   * their type is not known on runtime and the contructors of the types are not known.
+   * 
+   * The following cases are handled (in this precedence):
+   * 
+   * - Basic F# types (`bool`, `byte`, `sbyte`, `int16`, `uint16`, `int`, `uint`, `int64`, `uint64`, `nativeint`, `unativeint`, `float`, `float32`, `char`, `string`, `unit`, `decimal`)
+   * 
+   * - `ResizeArrays` and `Dictionaries` containing any combination of basic F# types
+   * 
+   * - `Dictionaries` containing `DynamicObj` as keys or values in any combination with `DynamicObj` or basic F# types as keys or values
+   * 
+   * - `array<DynamicObj>`, `list<DynamicObj>`, `ResizeArray<DynamicObj>`: These collections of DynamicObj are copied as a new collection with recursively deep copied elements.
+   * 
+   * - `System.ICloneable`: If the property implements `ICloneable`, the `Clone()` method is called on the property.
+   * 
+   * - `DynamicObj` (and derived classes): properties that are themselves `DynamicObj` instances are deep copied recursively.
+   * if a derived class has static properties (e.g. instance properties), these can be copied as dynamic properties on the new instance or ignored.
+   * 
+   * Note on Classes that inherit from `DynamicObj`:
+   * 
+   * Classes that inherit from DynamicObj will match the `DynamicObj` typecheck if they do not implement `ICloneable`.
+   * The deep copied instances will be cast to `DynamicObj` with deep copied dynamic properties. Staic/instance properties can be copied as dynamic properties on the new instance or be ignored.
+   * It should be possible to 'recover' the original type by checking if the needed properties exist as dynamic properties,
+   * and then passing them to the class constructor if needed.
+   */
+  DeepCopyProperties(includeInstanceProperties) {
+    const this$ = this;
+    return CopyUtils_tryDeepCopyObj_75B3D832(this$, defaultArg(includeInstanceProperties, true));
+  }
+  /**
+   * Operator to access a property by name
+   * 
+   * This method is not Fable-compatible and can therefore not be used in code that will be transpiled.
+   */
+  static op_Dynamic(lookup, name) {
+    const matchValue = lookup.TryGetPropertyValue(name);
+    if (matchValue == null) {
+      throw new Exception();
+    } else {
+      return value(matchValue);
+    }
+  }
+  /**
+   * Operator to set a property value
+   * 
+   * This method is not Fable-compatible and can therefore not be used in code that will be transpiled.
+   */
+  static op_DynamicAssignment(lookup, name, value) {
+    lookup.SetProperty(name, value);
+  }
+  ReferenceEquals(other) {
+    const this$ = this;
+    return this$ === other;
+  }
+  StructurallyEquals(other) {
+    const this$ = this;
+    return safeHash(this$) === safeHash(other);
+  }
+  GetHashCode() {
+    const this$ = this;
+    return HashUtils_deepHash_4E60E31B(this$) | 0;
+  }
+  Equals(o) {
+    let other = void 0;
+    const this$ = this;
+    return o instanceof DynamicObj && (other = o, this$.StructurallyEquals(other));
+  }
+}
+function DynamicObj_$reflection() {
+  return class_type("DynamicObj.DynamicObj", void 0, DynamicObj);
+}
+function DynamicObj_$ctor() {
+  return new DynamicObj();
+}
+class HashUtils {
+  constructor() {
+  }
+}
+function HashUtils_$reflection() {
+  return class_type("DynamicObj.HashUtils", void 0, HashUtils);
+}
+class CopyUtils {
+  constructor() {
+  }
+}
+function CopyUtils_$reflection() {
+  return class_type("DynamicObj.CopyUtils", void 0, CopyUtils);
+}
+function HashUtils_deepHash_4E60E31B(o) {
+  if (o instanceof DynamicObj) {
+    const o_1 = o;
+    return boxHashKeyValSeqBy((o_2) => HashUtils_deepHash_4E60E31B(o_2) | 0, sortBy((pair) => pair[0], o_1.GetProperties(true), {
+      Compare: (x, y) => comparePrimitives(x, y) | 0
+    })) | 0;
+  } else if (typeof o === "string") {
+    const s = o;
+    return hash(s) | 0;
+  } else if (isIterable(o)) {
+    const e = o;
+    const en = getEnumerator(e);
+    const l = toList(delay(() => enumerateWhile(() => en["System.Collections.IEnumerator.MoveNext"](), delay(() => singleton(HashUtils_deepHash_4E60E31B(en["System.Collections.IEnumerator.get_Current"]()))))));
+    if (isEmpty(l)) {
+      return 0;
+    } else {
+      return reduce((hash, hash_1) => mergeHashes(hash, hash_1) | 0, l) | 0;
+    }
+  } else {
+    return hash(o) | 0;
+  }
+}
+function CopyUtils_tryDeepCopyObj_75B3D832(o, includeInstanceProperties) {
+  const includeInstanceProperties_1 = defaultArg(includeInstanceProperties, true);
+  const tryDeepCopyObj = (o_1) => {
+    let matchResult = void 0, o_12 = void 0, o_14 = void 0, o_16 = void 0;
+    if (typeof o_1 === "boolean") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "bigint") {
+      matchResult = 0;
+    } else if (typeof o_1 === "bigint") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "number") {
+      matchResult = 0;
+    } else if (typeof o_1 === "string") {
+      matchResult = 0;
+    } else if (typeof o_1 === "string") {
+      matchResult = 0;
+    } else if (o_1 == null) {
+      matchResult = 0;
+    } else if (o_1 instanceof Big) {
+      matchResult = 1;
+    } else if (isArrayLike(o_1)) {
+      if (o_1 instanceof Map) {
+        matchResult = 2;
+        o_12 = o_1;
+      } else if (o_1 instanceof Dictionary) {
+        matchResult = 3;
+        o_14 = o_1;
+      } else {
+        matchResult = 4;
+      }
+    } else if (o_1 instanceof FSharpList) {
+      if (o_1 instanceof Map) {
+        matchResult = 2;
+        o_12 = o_1;
+      } else if (o_1 instanceof Dictionary) {
+        matchResult = 3;
+        o_14 = o_1;
+      } else {
+        matchResult = 5;
+      }
+    } else if (o_1 instanceof DynamicObj) {
+      if (o_1 instanceof Map) {
+        matchResult = 2;
+        o_12 = o_1;
+      } else if (o_1 instanceof Dictionary) {
+        matchResult = 3;
+        o_14 = o_1;
+      } else if (o_1["System.ICloneable.Clone"] != void 0 && typeof o_1["System.ICloneable.Clone"] === "function") {
+        matchResult = 6;
+        o_16 = o_1;
+      } else {
+        matchResult = 7;
+      }
+    } else if (o_1 instanceof Map) {
+      matchResult = 2;
+      o_12 = o_1;
+    } else if (o_1 instanceof Dictionary) {
+      matchResult = 3;
+      o_14 = o_1;
+    } else if (o_1["System.ICloneable.Clone"] != void 0 && typeof o_1["System.ICloneable.Clone"] === "function") {
+      matchResult = 6;
+      o_16 = o_1;
+    } else {
+      matchResult = 8;
+    }
+    switch (matchResult) {
+      case 0:
+        return o_1;
+      case 1:
+        return o_1;
+      case 2: {
+        const o_13 = o_12;
+        const newDict = new Dictionary([], {
+          Equals: equals,
+          GetHashCode: (x) => structuralHash(x) | 0
+        });
+        let enumerator = getEnumerator(o_13);
+        try {
+          while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const kv = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            addToDict(newDict, tryDeepCopyObj(kv[0]), tryDeepCopyObj(kv[1]));
+          }
+        } finally {
+          disposeSafe(enumerator);
+        }
+        return newDict;
+      }
+      case 3: {
+        const o_15 = o_14;
+        const newDict_1 = new Dictionary([], {
+          Equals: equals,
+          GetHashCode: (x_1) => structuralHash(x_1) | 0
+        });
+        let enumerator_1 = getEnumerator(o_15);
+        try {
+          while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            const kv_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            addToDict(newDict_1, tryDeepCopyObj(kv_1[0]), tryDeepCopyObj(kv_1[1]));
+          }
+        } finally {
+          disposeSafe(enumerator_1);
+        }
+        return newDict_1;
+      }
+      case 4: {
+        const dyns = o_1;
+        return Array.from(toList(delay(() => map((dyn) => tryDeepCopyObj(dyn), dyns))));
+      }
+      case 5: {
+        const dyns_1 = o_1;
+        return toList(delay(() => map((dyn_1) => tryDeepCopyObj(dyn_1), dyns_1)));
+      }
+      case 6:
+        return o_16["System.ICloneable.Clone"]();
+      case 7: {
+        const dyn_2 = o_1;
+        const newDyn = new DynamicObj();
+        const enumerator_2 = getEnumerator(dyn_2.GetProperties(includeInstanceProperties_1));
+        try {
+          while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+            const kv_2 = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            newDyn.SetProperty(kv_2[0], tryDeepCopyObj(kv_2[1]));
+          }
+        } finally {
+          disposeSafe(enumerator_2);
+        }
+        return newDyn;
+      }
+      default:
+        return o_1;
+    }
+  };
+  return tryDeepCopyObj(o);
+}
+
+export { CopyUtils, CopyUtils_$reflection, CopyUtils_tryDeepCopyObj_75B3D832, DynamicObj, DynamicObj_$ctor, DynamicObj_$reflection, HashUtils, HashUtils_$reflection, HashUtils_deepHash_4E60E31B };

package/dist/ts/ts/fable_modules/{DynamicObj.7.1.0 → DynamicObj.8.0.0}/FableJS.fs.js

@@ -1,11 +1,16 @@
-import { map, value, bind } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
-import { defaultOf } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { defaultOf } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
 import { PropertyHelper } from './PropertyHelper.fs.js';
-import { choose, append, map as map$1 } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
-import { isMatch, create } from '../../../node_modules/@fable-org/fable-library-js/RegExp.js';
+import { choose, append, map } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { isMatch, create } from '../../../node_modules/@fable-org/fable-library-ts/RegExp.js';
 
 function PropertyDescriptor_tryGetIsWritable(o) {
-  return map((v) => v, o["writable"]);
+  const option_1 = o["writable"];
+  if (option_1 != null) {
+    return value(option_1);
+  } else {
+    return void 0;
+  }
 }
 function PropertyDescriptor_containsGetter(o) {
   const matchValue = o["get"];
@@ -76,7 +81,12 @@ function tryStaticPropertyHelperFromDescriptor(pd, name) {
   }
 }
 function tryGetStaticPropertyHelper(o, propName) {
-  return bind((pd) => tryStaticPropertyHelperFromDescriptor(pd, propName), tryGetStaticPropertyDescriptor(o, propName));
+  const option_1 = tryGetStaticPropertyDescriptor(o, propName);
+  if (option_1 != null) {
+    return tryStaticPropertyHelperFromDescriptor(value(option_1), propName);
+  } else {
+    return void 0;
+  }
 }
 function getStaticPropertyHelpers(o) {
   return choose((propName) => tryGetStaticPropertyHelper(o, propName), getStaticPropertyNames(o));
@@ -98,7 +108,12 @@ function tryDynamicPropertyHelperFromDescriptor(pd, name) {
   }
 }
 function tryGetDynamicPropertyHelper(o, propName) {
-  return bind((pd) => tryDynamicPropertyHelperFromDescriptor(pd, propName), tryGetDynamicPropertyDescriptor(o, propName));
+  const option_1 = tryGetDynamicPropertyDescriptor(o, propName);
+  if (option_1 != null) {
+    return tryDynamicPropertyHelperFromDescriptor(value(option_1), propName);
+  } else {
+    return void 0;
+  }
 }
 function getDynamicPropertyHelpers(o) {
   return choose((propName) => tryGetDynamicPropertyHelper(o, propName), Object.getOwnPropertyNames(o));
@@ -108,7 +123,7 @@ function getPropertyHelpers(o) {
   return append(getStaticPropertyHelpers(o), array_1);
 }
 function getPropertyNames(o) {
-  return map$1((h) => h.Name, getPropertyHelpers(o));
+  return map((h) => h.Name, getPropertyHelpers(o));
 }
 
 export { PropertyDescriptor_containsGetter, PropertyDescriptor_containsSetter, PropertyDescriptor_isFunction, PropertyDescriptor_isWritable, PropertyDescriptor_tryGetIsWritable, createGetter, createRemover, createSetter, getDynamicPropertyHelpers, getPropertyHelpers, getPropertyNames, getStaticPropertyHelpers, getStaticPropertyNames, isTranspiledPropertyHelper, removeStaticPropertyValue, transpiledPropertyRegex, tryDynamicPropertyHelperFromDescriptor, tryGetDynamicPropertyDescriptor, tryGetDynamicPropertyHelper, tryGetStaticPropertyDescriptor, tryGetStaticPropertyHelper, tryStaticPropertyHelperFromDescriptor };

package/dist/ts/ts/fable_modules/{DynamicObj.7.1.0 → DynamicObj.8.0.0}/HashCodes.fs.js

@@ -1,11 +1,11 @@
-import { year, month, day, hour, minute, second } from '../../../node_modules/@fable-org/fable-library-js/Date.js';
-import { equals, defaultOf, identityHash, numberHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
-import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
-import { fold } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
-import { fold as fold$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { year, month, day, hour, minute, second } from '../../../node_modules/@fable-org/fable-library-ts/Date.js';
+import { equals, defaultOf, identityHash, numberHash } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { fold } from '../../../node_modules/@fable-org/fable-library-ts/Array.js';
+import { fold as fold$1 } from '../../../node_modules/@fable-org/fable-library-ts/Seq.js';
 
 function mergeHashes(hash1, hash2) {
-  return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2);
+  return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2) | 0;
 }
 function hashDateTime(dt) {
   let acc = 0;
@@ -26,20 +26,20 @@ function hash(obj) {
   }
 }
 function boxHashOption(a) {
-  let copyOfStruct, copyOfStruct_1;
+  let copyOfStruct = void 0, copyOfStruct_1 = void 0;
   return a != null ? (copyOfStruct = value(a), identityHash(copyOfStruct)) : (copyOfStruct_1 = 0, numberHash(copyOfStruct_1));
 }
 function boxHashArray(a) {
-  return fold((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+  return fold((acc, o) => mergeHashes(acc, hash(o)) | 0, 0, a);
 }
 function boxHashSeq(a) {
-  return fold$1((acc, o) => mergeHashes(acc, hash(o)), 0, a);
+  return fold$1((acc, o) => mergeHashes(acc, hash(o)) | 0, 0, a);
 }
 function boxHashKeyValSeq(a) {
-  return fold$1((acc, o) => mergeHashes(acc, mergeHashes(hash(o[0]), hash(o[1]))), 0, a);
+  return fold$1((acc, o) => mergeHashes(acc, mergeHashes(hash(o[0]), hash(o[1]))) | 0, 0, a);
 }
 function boxHashKeyValSeqBy(f, a) {
-  return fold$1((acc, o) => mergeHashes(acc, mergeHashes(hash(o[0]), f(o[1]))), 0, a);
+  return fold$1((acc, o) => mergeHashes(acc, mergeHashes(hash(o[0]), f(o[1]))) | 0, 0, a);
 }
 
 export { boxHashArray, boxHashKeyValSeq, boxHashKeyValSeqBy, boxHashOption, boxHashSeq, hash, hashDateTime, mergeHashes };

package/dist/ts/ts/fable_modules/{DynamicObj.7.1.0 → DynamicObj.8.0.0}/PropertyHelper.fs.js

@@ -1,5 +1,5 @@
-import { Record } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
-import { record_type, string_type, bool_type, lambda_type, obj_type, unit_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { Record } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { record_type, string_type, bool_type, lambda_type, obj_type, unit_type } from '../../../node_modules/@fable-org/fable-library-ts/Reflection.js';
 
 class PropertyHelper extends Record {
   constructor(Name, IsStatic, IsDynamic, IsMutable, IsImmutable, GetValue, SetValue, RemoveValue) {

package/dist/ts/ts/fable_modules/{DynamicObj.7.1.0 → DynamicObj.8.0.0}/ReflectionUtils.fs.js

@@ -1,5 +1,6 @@
 import { getStaticPropertyHelpers, tryGetStaticPropertyHelper } from './FableJS.fs.js';
-import { value, some, map } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { value, some } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { NullReferenceException } from '../../../node_modules/@fable-org/fable-library-ts/System.js';
 
 function getStaticProperties(o) {
   return getStaticPropertyHelpers(o);
@@ -9,7 +10,7 @@ function tryGetStaticPropertyInfo(o, propName) {
 }
 function trySetPropertyValue(o, propName, value$1) {
   const matchValue = tryGetStaticPropertyInfo(o, propName);
-  let matchResult, property_1;
+  let matchResult = void 0, property_1 = void 0;
   if (matchValue != null) {
     if (value(matchValue).IsMutable) {
       matchResult = 0;
@@ -34,19 +35,28 @@ function tryGetPropertyValue(o, propName) {
     const matchValue = tryGetStaticPropertyInfo(o, propName);
     return matchValue == null ? void 0 : some(value(matchValue).GetValue(o));
   } catch (matchValue_1) {
-    throw matchValue_1;
+    if (matchValue_1 instanceof NullReferenceException) {
+      return void 0;
+    } else {
+      throw matchValue_1;
+    }
   }
 }
 function tryGetPropertyValueAs(o, propName) {
   try {
-    return map((v) => v, tryGetPropertyValue(o, propName));
+    const option_1 = tryGetPropertyValue(o, propName);
+    return option_1 != null ? some(value(option_1)) : void 0;
   } catch (matchValue) {
-    throw matchValue;
+    if (matchValue instanceof NullReferenceException) {
+      return void 0;
+    } else {
+      throw matchValue;
+    }
   }
 }
 function removeProperty(o, propName) {
   const matchValue = tryGetStaticPropertyInfo(o, propName);
-  let matchResult, property_1;
+  let matchResult = void 0, property_1 = void 0;
   if (matchValue != null) {
     if (value(matchValue).IsMutable) {
       matchResult = 0;