Function parseSyntaxToAst

src/syntax/parser.ts:169–324

(input: string)

}

export function parseSyntaxToAst(input: string): ParseResult {
  const errors: SyntaxError[] = [];
  const root: ObjectNode = createObjectNode(0);
  const stack: StackFrame[] = [
    { indent: -1, node: root, parent: null, key: null },
  ];

  const lines = input.split(/\r?\n/);
  lines.forEach((line, index) => {
    const lineNumber = index + 1;
    if (!line.trim()) return;
    const { indent, content } = getIndentInfo(line);
    if (isCommentLine(content) || isCodeFenceLine(content)) return;
    const stripped = stripComments(content);
    if (!stripped.trim()) return;

    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
      stack.pop();
    }

    const parentFrame = stack[stack.length - 1];
    let parentNode = parentFrame.node;

    const trimmed = stripped.trim();
    if (
      trimmed.startsWith('-') &&
      (trimmed.length === 1 || isWhitespace(trimmed[1]))
    ) {
      if (parentNode.kind !== 'array') {
        if (
          parentNode.kind === 'object' &&
          Object.keys(parentNode.entries).length === 0 &&
          parentNode.value === undefined &&
          parentFrame.parent &&
          parentFrame.key
        ) {
          const arrayNode = createArrayNode(parentNode.line);
          if (parentFrame.parent.kind === 'object') {
            parentFrame.parent.entries[parentFrame.key] = arrayNode;
          } else if (parentFrame.parent.kind === 'array') {
            const indexInParent = parentFrame.parent.items.indexOf(parentNode);
            if (indexInParent >= 0)
              parentFrame.parent.items[indexInParent] = arrayNode;
          }
          parentFrame.node = arrayNode;
          parentNode = arrayNode;
        } else {
          errors.push({
            path: '',
            line: lineNumber,
            code: 'bad_list',
            message: 'List item is not under an array container.',
            raw: trimmed,
          });
          return;
        }
      }