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

package/dist/ts/ts/fable_modules/Thoth.Json.JavaScript.0.4.1/Encode.fs.js

@@ -0,0 +1,57 @@
+import { getEnumerator, disposeSafe, defaultOf } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { some } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+const helpers = {
+  encodeString(value) {
+    return value;
+  },
+  encodeChar(value_1) {
+    return value_1;
+  },
+  encodeDecimalNumber(value_2) {
+    return value_2;
+  },
+  encodeBool(value_3) {
+    return value_3;
+  },
+  encodeNull() {
+    return defaultOf();
+  },
+  encodeObject(values) {
+    const o = {};
+    const enumerator = getEnumerator(values);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        o[forLoopVar[0]] = forLoopVar[1];
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    return o;
+  },
+  encodeArray(values_1) {
+    return Array.from(values_1);
+  },
+  encodeList(values_2) {
+    return Array.from(values_2);
+  },
+  encodeSeq(values_3) {
+    return Array.from(values_3);
+  },
+  encodeResizeArray(values_4) {
+    return Array.from(values_4);
+  },
+  encodeSignedIntegralNumber(value_5) {
+    return value_5;
+  },
+  encodeUnsignedIntegralNumber(value_6) {
+    return value_6;
+  }
+};
+function toString(space, value) {
+  const json_1 = value.Encode(helpers);
+  return JSON.stringify(json_1, void 0, some(space));
+}
+
+export { helpers, toString };

package/dist/ts/ts/fable_modules/YAMLicious.0.0.3/Decode.fs.js

@@ -0,0 +1,235 @@
+import { toText, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { tryFind, map as map$1, filter, exists, iterate, isEmpty, head, tail } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { map, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+
+function string(value) {
+  let matchResult, v, anyElse;
+  switch (value.tag) {
+    case /* Value */
+    1: {
+      matchResult = 0;
+      v = value.fields[0];
+      break;
+    }
+    case /* Object */
+    3: {
+      if (!isEmpty(value.fields[0])) {
+        if (head(value.fields[0]).tag === /* Value */
+        1) {
+          if (isEmpty(tail(value.fields[0]))) {
+            matchResult = 0;
+            v = head(value.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+            anyElse = value;
+          }
+        } else {
+          matchResult = 1;
+          anyElse = value;
+        }
+      } else {
+        matchResult = 1;
+        anyElse = value;
+      }
+      break;
+    }
+    default: {
+      matchResult = 1;
+      anyElse = value;
+    }
+  }
+  switch (matchResult) {
+    case 0:
+      return v.Value;
+    default:
+      throw new Error(toText(printf("%s: %A"))("Expected a string")(anyElse) + "\\nParameter name: value");
+  }
+}
+function resizearray(decoder, value) {
+  let matchResult, v, anyElse;
+  switch (value.tag) {
+    case /* Sequence */
+    2: {
+      matchResult = 0;
+      v = value.fields[0];
+      break;
+    }
+    case /* Object */
+    3: {
+      if (!isEmpty(value.fields[0])) {
+        if (head(value.fields[0]).tag === /* Sequence */
+        2) {
+          if (isEmpty(tail(value.fields[0]))) {
+            matchResult = 0;
+            v = head(value.fields[0]).fields[0];
+          } else {
+            matchResult = 1;
+            anyElse = value;
+          }
+        } else {
+          matchResult = 1;
+          anyElse = value;
+        }
+      } else {
+        matchResult = 1;
+        anyElse = value;
+      }
+      break;
+    }
+    default: {
+      matchResult = 1;
+      anyElse = value;
+    }
+  }
+  switch (matchResult) {
+    case 0: {
+      const collection = map$1(decoder, v);
+      return Array.from(collection);
+    }
+    default:
+      throw new Error(toText(printf("%s: %A"))("Expected a resizearray")(anyElse) + "\\nParameter name: value");
+  }
+}
+class Getter {
+  constructor(ele) {
+    this.required = ({
+      Field(fieldName, dec) {
+        let arg_3;
+        if (ele.tag === /* Object */
+        3) {
+          const x = map((_arg_1) => {
+            if (_arg_1.tag === /* Mapping */
+            0) {
+              return dec(_arg_1.fields[1]);
+            } else {
+              throw new Error(toText(printf("%s: %A"))("Expected a mapping")(ele) + "\\nParameter name: value");
+            }
+          }, tryFind((_arg) => {
+            if (_arg.tag === /* Mapping */
+            0) {
+              return _arg.fields[0].Value === fieldName;
+            } else {
+              return false;
+            }
+          }, ele.fields[0]));
+          if (x == null) {
+            throw new Error((arg_3 = toText(printf("Field not found: %s"))(fieldName), toText(printf("%s: %A"))(arg_3)(ele)) + "\\nParameter name: value");
+          } else {
+            return value(x);
+          }
+        } else {
+          throw new Error(toText(printf("%s: %A"))("Expected an object")(ele) + "\\nParameter name: value");
+        }
+      }
+    });
+    this.optional = ({
+      Field(fieldName_1, dec_1) {
+        if (ele.tag === /* Object */
+        3) {
+          return map((_arg_3) => {
+            if (_arg_3.tag === /* Mapping */
+            0) {
+              return dec_1(_arg_3.fields[1]);
+            } else {
+              throw new Error(toText(printf("%s: %A"))("Expected a mapping")(ele) + "\\nParameter name: value");
+            }
+          }, tryFind((_arg_2) => {
+            if (_arg_2.tag === /* Mapping */
+            0) {
+              return _arg_2.fields[0].Value === fieldName_1;
+            } else {
+              return false;
+            }
+          }, ele.fields[0]));
+        } else {
+          throw new Error(toText(printf("%s: %A"))("Expected an object")(ele) + "\\nParameter name: value");
+        }
+      }
+    });
+    this.multipleOptional = ({
+      FieldList(fieldNames) {
+        if (ele.tag === /* Object */
+        3) {
+          const overflow = map$1((_arg_5) => {
+            if (_arg_5.tag === /* Mapping */
+            0) {
+              return [_arg_5.fields[0].Value, _arg_5.fields[1]];
+            } else {
+              throw new Error(toText(printf("%s: %A"))("Expected a mapping")(ele) + "\\nParameter name: value");
+            }
+          }, filter((_arg_4) => {
+            if (_arg_4.tag === /* Mapping */
+            0) {
+              const k_2 = _arg_4.fields[0];
+              return exists((x_1) => x_1 === k_2.Value, fieldNames);
+            } else {
+              return false;
+            }
+          }, ele.fields[0]));
+          const dict_1 = /* @__PURE__ */ new Map([]);
+          iterate((tupledArg) => {
+            addToDict(dict_1, tupledArg[0], tupledArg[1]);
+          }, overflow);
+          return dict_1;
+        } else {
+          throw new Error(toText(printf("%s: %A"))("Expected an object")(ele) + "\\nParameter name: value");
+        }
+      }
+    });
+    this.overflow = ({
+      FieldList(fieldNames_1) {
+        if (ele.tag === /* Object */
+        3) {
+          const overflow_1 = map$1((_arg_7) => {
+            if (_arg_7.tag === /* Mapping */
+            0) {
+              return [_arg_7.fields[0].Value, _arg_7.fields[1]];
+            } else {
+              throw new Error(toText(printf("%s: %A"))("Expected a mapping")(ele) + "\\nParameter name: value");
+            }
+          }, filter((_arg_6) => {
+            if (_arg_6.tag === /* Mapping */
+            0) {
+              const k_5 = _arg_6.fields[0];
+              return !exists((x_2) => x_2 === k_5.Value, fieldNames_1);
+            } else {
+              return false;
+            }
+          }, ele.fields[0]));
+          const dict_2 = /* @__PURE__ */ new Map([]);
+          iterate((tupledArg_1) => {
+            addToDict(dict_2, tupledArg_1[0], tupledArg_1[1]);
+          }, overflow_1);
+          return dict_2;
+        } else {
+          throw new Error(toText(printf("%s: %A"))("Expected an object")(ele) + "\\nParameter name: value");
+        }
+      }
+    });
+  }
+  get Required() {
+    const __ = this;
+    return __.required;
+  }
+  get Optional() {
+    const __ = this;
+    return __.optional;
+  }
+  get MultipleOptional() {
+    const __ = this;
+    return __.multipleOptional;
+  }
+  get Overflow() {
+    const __ = this;
+    return __.overflow;
+  }
+}
+function Getter_$ctor_D9C929(ele) {
+  return new Getter(ele);
+}
+function object(getter, value) {
+  return getter(Getter_$ctor_D9C929(value));
+}
+
+export { Getter, Getter_$ctor_D9C929, object, resizearray, string };

package/dist/ts/ts/fable_modules/YAMLicious.0.0.3/Encode.fs.js

@@ -0,0 +1,16 @@
+import { YAMLElement_Nil, YAMLElement_Sequence, YAMLElement_Value, YAMLContent_create_27AED5E3 } from './YAMLiciousTypes.fs.js';
+import { map, ofSeq } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+function string(value) {
+  return YAMLElement_Value(YAMLContent_create_27AED5E3(value));
+}
+function resizearray(encoder, arr) {
+  return YAMLElement_Sequence(map(encoder, ofSeq(arr)));
+}
+const nil = YAMLElement_Nil();
+function tryInclude(name, encoder, value$1) {
+  return [name, value$1 != null ? encoder(value(value$1)) : nil];
+}
+
+export { nil, resizearray, string, tryInclude };

package/dist/ts/ts/fable_modules/YAMLicious.0.0.3/Persil.fs.js

@@ -0,0 +1,45 @@
+import { split, replace as replace$1, toText, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { replace } from '../../../node_modules/@fable-org/fable-library-js/RegExp.js';
+import { addToDict } from '../../../node_modules/@fable-org/fable-library-js/MapUtil.js';
+
+function encodingCleanUp(s) {
+  return replace$1(s, "\r\n", "\n");
+}
+function stringCleanUp(dict, s) {
+  let n = 0;
+  return replace(/(?<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);
+    }
+  });
+}
+function commentCleanUp(dict, s) {
+  let n = 0;
+  return replace(/#(?<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);
+  });
+}
+function cut(yamlString) {
+  return split(yamlString, ["\n"], void 0, 1);
+}
+function pipeline(yamlString) {
+  const stringMap = /* @__PURE__ */ new Map([]);
+  const commentMap = /* @__PURE__ */ new Map([]);
+  return {
+    CommentMap: commentMap,
+    Lines: cut(commentCleanUp(commentMap, stringCleanUp(stringMap, encodingCleanUp(yamlString)))),
+    StringMap: stringMap
+  };
+}
+
+export { commentCleanUp, cut, encodingCleanUp, pipeline, stringCleanUp };

package/dist/ts/ts/fable_modules/YAMLicious.0.0.3/Preprocessing.fs.js

@@ -0,0 +1,89 @@
+import { length, takeWhile as takeWhile$1 } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { Preprocessor, PreprocessorElement_Level, Config_init_71136F3F, PreprocessorElement_Line, PreprocessorElement_Intendation, Config__get_WhitespaceString, Config } from './YAMLiciousTypes.fs.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { StringBuilder_$ctor, StringBuilder__AppendLine_Z721C83C5 } from '../../../node_modules/@fable-org/fable-library-js/System.Text.js';
+import { getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { pipeline } from './Persil.fs.js';
+import { reverse, empty, ofArray, isEmpty, tail, head, cons, takeWhile, skipWhile } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+
+function ReadHelpers_indentLevel(line) {
+  return length(takeWhile$1((c) => c === " ", line.split("")));
+}
+function write(rootElement, fconfig) {
+  let config_1;
+  const config = Config_init_71136F3F();
+  config_1 = fconfig != null ? value(fconfig)(config) : config;
+  const sb = StringBuilder_$ctor();
+  const loop = (current, sb_1, config_2) => {
+    switch (current.tag) {
+      case /* Intendation */
+      1: {
+        const nextConfig = new Config(config_2.Whitespace, config_2.Level + 1);
+        const enumerator = getEnumerator(current.fields[0]);
+        try {
+          while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            loop(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), sb_1, nextConfig);
+          }
+        } finally {
+          disposeSafe(enumerator);
+        }
+        break;
+      }
+      case /* Level */
+      0: {
+        const enumerator_1 = getEnumerator(current.fields[0]);
+        try {
+          while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+            loop(enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"](), sb_1, config_2);
+          }
+        } finally {
+          disposeSafe(enumerator_1);
+        }
+        break;
+      }
+      case /* Nil */
+      3: {
+        break;
+      }
+      default: {
+        const line = current.fields[0];
+        StringBuilder__AppendLine_Z721C83C5(sb_1, Config__get_WhitespaceString(config_2) + line);
+      }
+    }
+  };
+  loop(rootElement, sb, config_1);
+  return toString(sb);
+}
+function read(yamlStr) {
+  const content = pipeline(yamlStr);
+  const loop = (lines_mut, currentIntendation_mut, acc_mut) => {
+    loop:
+      while (true) {
+        const lines = lines_mut, currentIntendation = currentIntendation_mut, acc = acc_mut;
+        if (!isEmpty(lines)) {
+          const rest = tail(lines);
+          const line = head(lines);
+          const lineEle = PreprocessorElement_Line(line.trim());
+          const nextIntendation = ReadHelpers_indentLevel(line) | 0;
+          if (nextIntendation === currentIntendation) {
+            lines_mut = rest;
+            currentIntendation_mut = currentIntendation;
+            acc_mut = cons(PreprocessorElement_Line(line.trim()), acc);
+            continue loop;
+          } else {
+            const nextLevelLines = takeWhile((l) => ReadHelpers_indentLevel(l) > currentIntendation, rest);
+            lines_mut = skipWhile((l_1) => ReadHelpers_indentLevel(l_1) > currentIntendation, rest);
+            currentIntendation_mut = currentIntendation;
+            acc_mut = cons(PreprocessorElement_Intendation(cons(lineEle, reverse(loop(nextLevelLines, nextIntendation, empty())))), acc);
+            continue loop;
+          }
+        } else {
+          return acc;
+        }
+      }
+  };
+  return new Preprocessor(PreprocessorElement_Level(reverse(loop(ofArray(content.Lines), 0, empty()))), content.StringMap, content.CommentMap);
+}
+
+export { ReadHelpers_indentLevel, read, write };