@nfdi4plants/arctrl 3.0.0-beta.3 → 3.0.0-beta.4

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

@@ -0,0 +1,344 @@
+import { safeHash, isIterable, getEnumerator, isArrayLike, disposeSafe, structuralHash, equals, comparePrimitives } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { tryGetStaticPropertyInfo } from './ReflectionUtils.fs.js';
+import { value, map, defaultArg } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { tryGetDynamicPropertyHelper, getPropertyHelpers } from './FableJS.fs.js';
+import { filter, choose, map as map$1, iterate, sortBy, toList, delay, enumerateWhile, singleton } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { boxHashKeyValSeqBy, hash, mergeHashes } from './HashCodes.fs.js';
+import { isEmpty, reduce, FSharpList } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { Dictionary } from '../../../node_modules/@fable-org/fable-library-js/MutableMap.js';
+import { addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import '../../../node_modules/@fable-org/fable-library-js/Decimal.js';
+import { Big } from '../../../node_modules/@fable-org/fable-library-js/lib/big.js';
+
+class DynamicObj {
+  constructor() {
+    this.properties = /* @__PURE__ */ 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) : value(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(matchValue);
+    }
+  }
+  SetProperty(propertyName, propertyValue) {
+    const this$ = this;
+    const matchValue = this$.TryGetStaticPropertyHelper(propertyName);
+    if (matchValue == null) {
+      this$[propertyName] = propertyValue;
+    } else {
+      const pi = value(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 (value(matchValue).IsMutable) {
+      const pi_1 = value(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 void 0;
+      }
+    }, this$.GetPropertyHelpers(includeInstanceProperties));
+  }
+  GetPropertyNames(includeInstanceProperties) {
+    const this$ = this;
+    return map$1((kv) => kv[0], this$.GetProperties(includeInstanceProperties));
+  }
+  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));
+  }
+  ShallowCopyDynamicProperties() {
+    const this$ = this;
+    const target = new DynamicObj();
+    this$.ShallowCopyDynamicPropertiesTo(target, true);
+    return target;
+  }
+  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));
+  }
+  DeepCopyProperties(includeInstanceProperties) {
+    const this$ = this;
+    return CopyUtils_tryDeepCopyObj_75B3D832(this$, defaultArg(includeInstanceProperties, true));
+  }
+  static op_Dynamic(lookup, name) {
+    const matchValue = lookup.TryGetPropertyValue(name);
+    if (matchValue == null) {
+      throw new Error();
+    } else {
+      return value(matchValue);
+    }
+  }
+  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;
+    const this$ = this;
+    return o instanceof DynamicObj && (other = o, this$.StructurallyEquals(other));
+  }
+}
+function HashUtils_deepHash_4E60E31B(o) {
+  if (o instanceof DynamicObj) {
+    const o_1 = o;
+    return boxHashKeyValSeqBy(HashUtils_deepHash_4E60E31B, sortBy((pair) => pair[0], o_1.GetProperties(true), {
+      Compare: comparePrimitives
+    })) | 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(mergeHashes, 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, o_12, o_14, o_16;
+    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: structuralHash
+        });
+        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: structuralHash
+        });
+        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$1((dyn) => tryDeepCopyObj(dyn), dyns))));
+      }
+      case 5: {
+        const dyns_1 = o_1;
+        return toList(delay(() => map$1((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_tryDeepCopyObj_75B3D832, DynamicObj, HashUtils_deepHash_4E60E31B };

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/FableJS.fs.js

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

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/HashCodes.fs.js

@@ -0,0 +1,19 @@
+import { equals, defaultOf, identityHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { fold } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+
+function mergeHashes(hash1, hash2) {
+  return -1640531527 + hash2 + (hash1 << 6) + (hash1 >> 2);
+}
+function hash(obj) {
+  if (equals(obj, defaultOf())) {
+    return 0;
+  } else {
+    let copyOfStruct = obj;
+    return identityHash(copyOfStruct) | 0;
+  }
+}
+function boxHashKeyValSeqBy(f, a) {
+  return fold((acc, o) => mergeHashes(acc, mergeHashes(hash(o[0]), f(o[1]))), 0, a);
+}
+
+export { boxHashKeyValSeqBy, hash, mergeHashes };

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/PropertyHelper.fs.js

@@ -0,0 +1,17 @@
+import { Record } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+
+class PropertyHelper extends Record {
+  constructor(Name, IsStatic, IsDynamic, IsMutable, IsImmutable, GetValue, SetValue, RemoveValue) {
+    super();
+    this.Name = Name;
+    this.IsStatic = IsStatic;
+    this.IsDynamic = IsDynamic;
+    this.IsMutable = IsMutable;
+    this.IsImmutable = IsImmutable;
+    this.GetValue = GetValue;
+    this.SetValue = SetValue;
+    this.RemoveValue = RemoveValue;
+  }
+}
+
+export { PropertyHelper };

package/dist/ts/ts/fable_modules/DynamicObj.7.0.1/ReflectionUtils.fs.js

@@ -0,0 +1,7 @@
+import { tryGetStaticPropertyHelper } from './FableJS.fs.js';
+
+function tryGetStaticPropertyInfo(o, propName) {
+  return tryGetStaticPropertyHelper(o, propName);
+}
+
+export { tryGetStaticPropertyInfo };

package/dist/ts/ts/fable_modules/Fable.Exceljs.1.6.0/ExcelJs.fs.js

@@ -0,0 +1,5 @@
+import exceljs from '@nfdi4plants/exceljs';
+
+const Excel = exceljs;
+
+export { Excel };

package/dist/ts/ts/fable_modules/Fable.Fetch.2.6.0/Fetch.fs.js

@@ -0,0 +1,18 @@
+import { keyValueList } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+import { int32ToString } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+
+function errorString(response) {
+  return int32ToString(response.status) + " " + response.statusText + " for URL " + response.url;
+}
+function fetch$(url, init) {
+  const pr = fetch(url, keyValueList(init, 1));
+  return pr.then((response) => {
+    if (response.ok) {
+      return response;
+    } else {
+      throw new Error(errorString(response));
+    }
+  });
+}
+
+export { fetch$ };

package/dist/ts/ts/fable_modules/Fable.Promise.3.2.0/Promise.fs.js

@@ -0,0 +1,44 @@
+class PromiseBuilder {
+  constructor() {
+  }
+}
+function PromiseBuilder_$ctor() {
+  return new PromiseBuilder();
+}
+function PromiseBuilder__Delay_62FBFDE1(_, generator) {
+  return {
+    then: (onSuccess, onError) => {
+      try {
+        return generator().then(onSuccess, onError);
+      } catch (er) {
+        if (onError == null) {
+          return Promise.reject(er);
+        } else {
+          try {
+            const a = onError(er);
+            return Promise.resolve(a);
+          } catch (er_1) {
+            return Promise.reject(er_1);
+          }
+        }
+      }
+    },
+    catch: (onError_1) => {
+      try {
+        return generator().catch(onError_1);
+      } catch (er_2) {
+        try {
+          const a_1 = onError_1(er_2);
+          return Promise.resolve(a_1);
+        } catch (er_3) {
+          return Promise.reject(er_3);
+        }
+      }
+    }
+  };
+}
+function PromiseBuilder__Run_212F1D4B(_, p) {
+  return p.then((x) => x);
+}
+
+export { PromiseBuilder, PromiseBuilder_$ctor, PromiseBuilder__Delay_62FBFDE1, PromiseBuilder__Run_212F1D4B };

package/dist/ts/ts/fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs.js

@@ -0,0 +1,5 @@
+import { PromiseBuilder_$ctor } from './Promise.fs.js';
+
+const promise = PromiseBuilder_$ctor();
+
+export { promise };