@nfdi4plants/arctrl 3.1.0 → 3.2.0

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

@@ -0,0 +1,319 @@
+import { Placeholder_isCommentOnlyLine, Line_countLeadingSpaces, BlockScalar_isHeaderLine } from './Syntax.fs.js';
+import { tryFind, isEmpty, head, tail, reverse, cons, empty, ofArray, ofSeq } from '../../../node_modules/@fable-org/fable-library-ts/List.js';
+import { value } from '../../../node_modules/@fable-org/fable-library-ts/Option.js';
+import { Config_init_71136F3F, Config__get_WhitespaceString, Config, PreprocessorElement_Line, PreprocessorElement_Intendation, Preprocessor, PreprocessorElement_Level } from './YAMLiciousTypes.fs.js';
+import { StringBuilder_$ctor, StringBuilder__AppendLine_Z721C83C5 } from '../../../node_modules/@fable-org/fable-library-ts/System.Text.js';
+import { getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-ts/Util.js';
+import { toString } from '../../../node_modules/@fable-org/fable-library-ts/Types.js';
+import { pipeline } from './Persil.fs.js';
+import { substring, trimStart, trimEnd } from '../../../node_modules/@fable-org/fable-library-ts/String.js';
+
+function isPresentationOnlyLine(line) {
+  if (line.trim() === "") {
+    return true;
+  } else {
+    return Placeholder_isCommentOnlyLine(line);
+  }
+}
+function tryFindContentLine(lines) {
+  return tryFind((arg) => !isPresentationOnlyLine(arg), lines);
+}
+function shouldStayInNestedBlock(currentIntendation, inBlockScalar, line, rest) {
+  let nextLine_1 = void 0;
+  if (line.trim() === "") {
+    if (inBlockScalar) {
+      const matchValue = tryFind((l) => l.trim() !== "", rest);
+      if (matchValue == null) {
+        return true;
+      } else {
+        return Line_countLeadingSpaces(value(matchValue)) > currentIntendation;
+      }
+    } else {
+      const matchValue_1 = tryFind((l_1) => l_1.trim() !== "", rest);
+      if (matchValue_1 == null) {
+        return true;
+      } else if (nextLine_1 = value(matchValue_1), Placeholder_isCommentOnlyLine(nextLine_1) && Line_countLeadingSpaces(nextLine_1) <= currentIntendation) {
+        const nextLine_2 = value(matchValue_1);
+        const matchValue_2 = tryFindContentLine(rest);
+        if (matchValue_2 == null) {
+          return true;
+        } else {
+          return Line_countLeadingSpaces(value(matchValue_2)) > currentIntendation;
+        }
+      } else {
+        const nextLine_3 = value(matchValue_1);
+        return Line_countLeadingSpaces(nextLine_3) > currentIntendation;
+      }
+    }
+  } else if (Placeholder_isCommentOnlyLine(line)) {
+    if (inBlockScalar) {
+      return Line_countLeadingSpaces(line) > currentIntendation;
+    } else if (Line_countLeadingSpaces(line) > currentIntendation) {
+      return true;
+    } else {
+      const matchValue_3 = tryFindContentLine(rest);
+      if (matchValue_3 == null) {
+        return true;
+      } else {
+        return Line_countLeadingSpaces(value(matchValue_3)) > currentIntendation;
+      }
+    }
+  } else {
+    return Line_countLeadingSpaces(line) > currentIntendation;
+  }
+}
+function splitNestedBlock(currentIntendation, inBlockScalar, lines) {
+  const loop = (acc_mut, remaining_mut) => {
+    loop:
+      while (true) {
+        const acc = acc_mut, remaining = remaining_mut;
+        let matchResult = void 0, line_1 = void 0, rest_1 = void 0;
+        if (!isEmpty(remaining)) {
+          if (shouldStayInNestedBlock(currentIntendation, inBlockScalar, head(remaining), tail(remaining))) {
+            matchResult = 0;
+            line_1 = head(remaining);
+            rest_1 = tail(remaining);
+          } else {
+            matchResult = 1;
+          }
+        } else {
+          matchResult = 1;
+        }
+        switch (matchResult) {
+          case 0: {
+            acc_mut = cons(line_1, acc);
+            remaining_mut = rest_1;
+            continue loop;
+          }
+          default:
+            return [reverse(acc), remaining];
+        }
+        break;
+      }
+  };
+  return loop(empty(), lines);
+}
+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 stripIndent = (indent, line) => {
+    if (indent <= 0) {
+      return line;
+    } else if (Line_countLeadingSpaces(line) >= indent) {
+      return substring(line, indent);
+    } else {
+      return trimStart(line);
+    }
+  };
+  const loop = (lines_mut, currentIntendation_mut, inBlockScalar_mut, acc_mut) => {
+    loop:
+      while (true) {
+        const lines = lines_mut, currentIntendation = currentIntendation_mut, inBlockScalar = inBlockScalar_mut, acc = acc_mut;
+        const previousContentLine = () => tryFind((_arg) => {
+          if (_arg.tag === /* Line */
+          2) {
+            const line_1 = _arg.fields[0];
+            return line_1.trim() !== "";
+          } else {
+            return true;
+          }
+        }, acc);
+        const canStartNestedBlockAfterPresentation = () => {
+          const _arg_1 = previousContentLine();
+          let matchResult = void 0, line_2 = void 0;
+          if (_arg_1 != null) {
+            if (value(_arg_1).tag === /* Line */
+            2) {
+              matchResult = 0;
+              line_2 = value(_arg_1).fields[0];
+            } else {
+              matchResult = 1;
+            }
+          } else {
+            matchResult = 1;
+          }
+          switch (matchResult) {
+            case 0: {
+              const trimmed = trimEnd(line_2);
+              if ((trimmed.endsWith(":") ? true : trimmed.endsWith("[")) ? true : trimmed.endsWith("{")) {
+                return true;
+              } else {
+                return BlockScalar_isHeaderLine(trimmed);
+              }
+            }
+            default:
+              return false;
+          }
+        };
+        const nestedBlockScalarAfterPresentation = () => {
+          const matchValue = previousContentLine();
+          let matchResult_1 = void 0, line_3 = void 0;
+          if (matchValue != null) {
+            if (value(matchValue).tag === /* Line */
+            2) {
+              matchResult_1 = 0;
+              line_3 = value(matchValue).fields[0];
+            } else {
+              matchResult_1 = 1;
+            }
+          } else {
+            matchResult_1 = 1;
+          }
+          switch (matchResult_1) {
+            case 0:
+              return BlockScalar_isHeaderLine(trimEnd(line_3));
+            default:
+              return false;
+          }
+        };
+        if (!isEmpty(lines)) {
+          const rest = tail(lines);
+          const line_4 = head(lines);
+          const isEmptyLine = line_4.trim() === "";
+          const isCommentLine = Placeholder_isCommentOnlyLine(line_4);
+          if (isEmptyLine) {
+            const nextIndentedLine = tryFind((l) => l.trim() !== "", rest);
+            let matchResult_2 = void 0, nextLine_1 = void 0;
+            if (nextIndentedLine != null) {
+              if (Line_countLeadingSpaces(value(nextIndentedLine)) > currentIntendation && ((isEmpty(acc) ? true : inBlockScalar) ? true : canStartNestedBlockAfterPresentation())) {
+                matchResult_2 = 0;
+                nextLine_1 = value(nextIndentedLine);
+              } else {
+                matchResult_2 = 1;
+              }
+            } else {
+              matchResult_2 = 1;
+            }
+            switch (matchResult_2) {
+              case 0: {
+                const nextIntendation = Line_countLeadingSpaces(nextLine_1) | 0;
+                const childInBlockScalar = inBlockScalar ? true : nestedBlockScalarAfterPresentation();
+                const patternInput = splitNestedBlock(currentIntendation, childInBlockScalar, cons(line_4, rest));
+                lines_mut = patternInput[1];
+                currentIntendation_mut = currentIntendation;
+                inBlockScalar_mut = inBlockScalar;
+                acc_mut = cons(PreprocessorElement_Intendation(reverse(loop(patternInput[0], nextIntendation, childInBlockScalar, empty()))), acc);
+                continue loop;
+              }
+              default: {
+                lines_mut = rest;
+                currentIntendation_mut = currentIntendation;
+                inBlockScalar_mut = inBlockScalar;
+                acc_mut = cons(PreprocessorElement_Line(""), acc);
+                continue loop;
+              }
+            }
+          } else if (isCommentLine) {
+            const nextIndentedLine_1 = tryFindContentLine(rest);
+            let matchResult_3 = void 0, nextLine_3 = void 0;
+            if (nextIndentedLine_1 != null) {
+              if (Line_countLeadingSpaces(value(nextIndentedLine_1)) > currentIntendation && canStartNestedBlockAfterPresentation()) {
+                matchResult_3 = 0;
+                nextLine_3 = value(nextIndentedLine_1);
+              } else {
+                matchResult_3 = 1;
+              }
+            } else {
+              matchResult_3 = 1;
+            }
+            switch (matchResult_3) {
+              case 0: {
+                const nextIntendation_1 = Line_countLeadingSpaces(nextLine_3) | 0;
+                const childInBlockScalar_1 = inBlockScalar ? true : nestedBlockScalarAfterPresentation();
+                const patternInput_1 = splitNestedBlock(currentIntendation, childInBlockScalar_1, cons(line_4, rest));
+                lines_mut = patternInput_1[1];
+                currentIntendation_mut = currentIntendation;
+                inBlockScalar_mut = inBlockScalar;
+                acc_mut = cons(PreprocessorElement_Intendation(reverse(loop(patternInput_1[0], nextIntendation_1, childInBlockScalar_1, empty()))), acc);
+                continue loop;
+              }
+              default: {
+                lines_mut = rest;
+                currentIntendation_mut = currentIntendation;
+                inBlockScalar_mut = inBlockScalar;
+                acc_mut = cons(PreprocessorElement_Line(stripIndent(currentIntendation, line_4)), acc);
+                continue loop;
+              }
+            }
+          } else {
+            const nextIntendation_2 = Line_countLeadingSpaces(line_4) | 0;
+            if (nextIntendation_2 === currentIntendation) {
+              lines_mut = rest;
+              currentIntendation_mut = currentIntendation;
+              inBlockScalar_mut = inBlockScalar;
+              acc_mut = cons(PreprocessorElement_Line(stripIndent(currentIntendation, line_4)), acc);
+              continue loop;
+            } else {
+              const lineText_2 = stripIndent(nextIntendation_2, line_4);
+              const childInBlockScalar_2 = inBlockScalar ? true : nestedBlockScalarAfterPresentation();
+              const patternInput_2 = splitNestedBlock(currentIntendation, childInBlockScalar_2, rest);
+              lines_mut = patternInput_2[1];
+              currentIntendation_mut = currentIntendation;
+              inBlockScalar_mut = inBlockScalar;
+              acc_mut = cons(PreprocessorElement_Intendation(cons(PreprocessorElement_Line(lineText_2), reverse(loop(patternInput_2[0], nextIntendation_2, childInBlockScalar_2, empty())))), acc);
+              continue loop;
+            }
+          }
+        } else {
+          return acc;
+        }
+        break;
+      }
+  };
+  return new Preprocessor(PreprocessorElement_Level(reverse(loop(ofArray(content.Lines), 0, false, empty()))), content.StringMap, content.CommentMap, content.YAMLVersion, content.TagHandles);
+}
+function mkLine(line) {
+  return PreprocessorElement_Line(line);
+}
+function mklLevel(children) {
+  return PreprocessorElement_Level(ofSeq(children));
+}
+function mkIntendation(children) {
+  return PreprocessorElement_Intendation(ofSeq(children));
+}
+
+export { mkIntendation, mkLine, mklLevel, read, write };