@swagger-api/apidom-parser-adapter-yaml-1-2 1.11.0 → 1.11.2

package/src/syntactic-analysis/direct/index.mjs

@@ -0,0 +1,385 @@
+import { ParseResultElement, ObjectElement, ArrayElement, MemberElement, AnnotationElement, CommentElement, isPrimitiveElement, createNamespace } from '@swagger-api/apidom-core';
+import { formatFlowPlain, formatFlowSingleQuoted, formatFlowDoubleQuoted, formatBlockLiteral, formatBlockFolded } from '@swagger-api/apidom-ast';
+
+/**
+ * @public
+ */
+
+/**
+ * Thrown when the direct analysis encounters a YAML feature (tag, anchor, alias)
+ * that requires the full indirect two-pass analysis.
+ * @public
+ */
+export class FallbackNeeded extends Error {
+  name = 'FallbackNeeded';
+}
+
+// YAML 1.2 Core Schema type detection — matches apidom-ast/yaml/schemas/json/* order:
+// Null → Integer → FloatingPoint → Boolean
+const NULL_RE = /^null$/;
+const INT_RE = /^-?(0|[1-9][0-9]*)$/;
+const FLOAT_RE = /^-?(0|[1-9][0-9]*)(\.[0-9]*)?([eE][-+]?[0-9]+)?$/;
+const BOOL_RE = /^(true|false)$/;
+function resolveScalarContent(s) {
+  if (NULL_RE.test(s)) return null;
+  if (INT_RE.test(s)) return parseInt(s, 10);
+  if (FLOAT_RE.test(s)) return parseFloat(s);
+  if (BOOL_RE.test(s)) return s === 'true';
+  return s;
+}
+function setSourceMap(element, cursor) {
+  // eslint-disable-next-line no-param-reassign
+  element.startPositionRow = cursor.startPosition.row;
+  // eslint-disable-next-line no-param-reassign
+  element.startPositionColumn = cursor.startPosition.column;
+  // eslint-disable-next-line no-param-reassign
+  element.startIndex = cursor.startIndex;
+  // eslint-disable-next-line no-param-reassign
+  element.endPositionRow = cursor.endPosition.row;
+  // eslint-disable-next-line no-param-reassign
+  element.endPositionColumn = cursor.endPosition.column;
+  // eslint-disable-next-line no-param-reassign
+  element.endIndex = cursor.endIndex;
+}
+
+/**
+ * Iterates named children of the current cursor node.
+ * Adds warning annotations for missing unnamed (structural) nodes.
+ * Restores cursor to parent when done.
+ */
+const forEachNamedChild = (cursor, ctx, fn) => {
+  if (!cursor.gotoFirstChild()) return;
+  do {
+    if (!cursor.nodeIsNamed) {
+      if (cursor.nodeIsMissing) {
+        const ann = new AnnotationElement(`(Missing ${cursor.nodeType})`);
+        ann.classes.push('warning');
+        if (ctx.sourceMap) setSourceMap(ann, cursor);
+        ctx.annotations.push(ann);
+      }
+    } else {
+      var _cursor$currentFieldN;
+      fn(cursor, (_cursor$currentFieldN = cursor.currentFieldName) !== null && _cursor$currentFieldN !== void 0 ? _cursor$currentFieldN : null);
+    }
+  } while (cursor.gotoNextSibling());
+  cursor.gotoParent();
+};
+const walkFunctions = {
+  walkStream: (cursor, ctx) => {
+    const parseResult = new ParseResultElement();
+    if (ctx.sourceMap) setSourceMap(parseResult, cursor);
+    forEachNamedChild(cursor, ctx, child => {
+      const {
+        nodeType
+      } = child;
+      if (nodeType === 'document') {
+        const docContent = walkFunctions.walkDocument(child, ctx);
+        if (docContent !== null) parseResult.push(docContent);
+      } else if (nodeType === 'comment' && ctx.documentCount === 0) {
+        const comment = new CommentElement(child.nodeText);
+        if (ctx.sourceMap) setSourceMap(comment, child);
+        parseResult.push(comment);
+      } else if (nodeType === 'ERROR') {
+        walkFunctions.walkError(child, ctx);
+      }
+    });
+
+    // Mark the first content element as 'result' (matches YamlAstVisitor.stream.leave behaviour)
+    // @ts-ignore
+    const resultCandidates = parseResult.findElements(isPrimitiveElement);
+    if (resultCandidates.length > 0) {
+      resultCandidates[0].classes.push('result');
+    }
+    ctx.annotations.forEach(ann => parseResult.push(ann));
+    ctx.annotations = [];
+    return parseResult;
+  },
+  walkDocument: (cursor, ctx) => {
+    if (ctx.documentCount >= 1) {
+      if (ctx.documentCount === 1) {
+        const ann = new AnnotationElement('Only first document within YAML stream will be used. Rest will be discarded.');
+        ann.classes.push('warning');
+        if (ctx.sourceMap) setSourceMap(ann, cursor);
+        ctx.annotations.push(ann);
+      }
+      ctx.documentCount += 1;
+      return null;
+    }
+    ctx.documentCount += 1;
+    let content = null;
+    forEachNamedChild(cursor, ctx, child => {
+      const {
+        nodeType
+      } = child;
+      if (nodeType === 'tag' || nodeType === 'anchor' || nodeType === 'alias') {
+        throw new FallbackNeeded();
+      }
+      if (nodeType.endsWith('_directive') || nodeType === 'comment') return;
+      if (nodeType === 'ERROR') {
+        walkFunctions.walkError(child, ctx);
+        return;
+      }
+      const result = walkFunctions.walkNode(child, ctx);
+      if (result !== null) content = result;
+    });
+    return content;
+  },
+  walkMapping: (cursor, ctx) => {
+    const element = new ObjectElement();
+    if (ctx.sourceMap) setSourceMap(element, cursor);
+    forEachNamedChild(cursor, ctx, child => {
+      const {
+        nodeType
+      } = child;
+      if (nodeType === 'tag' || nodeType === 'anchor' || nodeType === 'alias') {
+        throw new FallbackNeeded();
+      }
+      if (nodeType === 'block_mapping_pair' || nodeType === 'flow_pair') {
+        element.push(walkFunctions.walkPair(child, ctx));
+      } else if (nodeType === 'ERROR') {
+        walkFunctions.walkError(child, ctx);
+      }
+    });
+    return element;
+  },
+  walkSequence: (cursor, ctx) => {
+    const element = new ArrayElement();
+    if (ctx.sourceMap) setSourceMap(element, cursor);
+    forEachNamedChild(cursor, ctx, child => {
+      const {
+        nodeType
+      } = child;
+      if (nodeType === 'tag' || nodeType === 'anchor' || nodeType === 'alias') {
+        throw new FallbackNeeded();
+      }
+      if (nodeType === 'ERROR') {
+        walkFunctions.walkError(child, ctx);
+      } else if (nodeType === 'block_sequence_item') {
+        const item = walkFunctions.walkSequenceItem(child, ctx);
+        if (item !== null) element.push(item);
+      } else {
+        // flow_sequence items (flow_node, flow_pair, scalars) appear directly
+        const item = walkFunctions.walkNode(child, ctx);
+        if (item !== null) element.push(item);
+      }
+    });
+    return element;
+  },
+  walkPair: (cursor, ctx) => {
+    const pairStartRow = cursor.startPosition.row;
+    const pairStartCol = cursor.startPosition.column;
+    const pairStartIdx = cursor.startIndex;
+    const pairEndRow = cursor.endPosition.row;
+    const pairEndCol = cursor.endPosition.column;
+    const pairEndIdx = cursor.endIndex;
+    let keyElement = null;
+    let valueElement = null;
+    forEachNamedChild(cursor, ctx, (child, fieldName) => {
+      const {
+        nodeType
+      } = child;
+      if (nodeType === 'tag' || nodeType === 'anchor' || nodeType === 'alias') {
+        throw new FallbackNeeded();
+      }
+      if (nodeType === 'ERROR') {
+        walkFunctions.walkError(child, ctx);
+      } else if (fieldName === 'key') {
+        keyElement = walkFunctions.walkNode(child, ctx);
+      } else if (fieldName === 'value') {
+        valueElement = walkFunctions.walkNode(child, ctx);
+      }
+    });
+    if (keyElement === null) {
+      keyElement = ctx.namespace.toElement('');
+      keyElement.classes.push('yaml-e-node');
+      keyElement.classes.push('yaml-e-scalar');
+      if (ctx.sourceMap) {
+        keyElement.startPositionRow = pairStartRow;
+        keyElement.startPositionColumn = pairStartCol;
+        keyElement.startIndex = pairStartIdx;
+        keyElement.endPositionRow = pairStartRow;
+        keyElement.endPositionColumn = pairStartCol;
+        keyElement.endIndex = pairStartIdx;
+      }
+    }
+    if (valueElement === null) {
+      valueElement = ctx.namespace.toElement('');
+      valueElement.classes.push('yaml-e-node');
+      valueElement.classes.push('yaml-e-scalar');
+      if (ctx.sourceMap) {
+        valueElement.startPositionRow = pairEndRow;
+        valueElement.startPositionColumn = pairEndCol;
+        valueElement.startIndex = pairEndIdx;
+        valueElement.endPositionRow = pairEndRow;
+        valueElement.endPositionColumn = pairEndCol;
+        valueElement.endIndex = pairEndIdx;
+      }
+    }
+    const member = new MemberElement();
+    if (ctx.sourceMap) {
+      member.startPositionRow = pairStartRow;
+      member.startPositionColumn = pairStartCol;
+      member.startIndex = pairStartIdx;
+      member.endPositionRow = pairEndRow;
+      member.endPositionColumn = pairEndCol;
+      member.endIndex = pairEndIdx;
+    }
+    member.key = keyElement;
+    member.value = valueElement;
+    return member;
+  },
+  walkSequenceItem: (cursor, ctx) => {
+    const endRow = cursor.endPosition.row;
+    const endCol = cursor.endPosition.column;
+    const endIdx = cursor.endIndex;
+    let content = null;
+    forEachNamedChild(cursor, ctx, child => {
+      const {
+        nodeType
+      } = child;
+      if (nodeType === 'tag' || nodeType === 'anchor' || nodeType === 'alias') {
+        throw new FallbackNeeded();
+      }
+      const result = walkFunctions.walkNode(child, ctx);
+      if (result !== null) content = result;
+    });
+    if (content === null) {
+      // empty sequence item (just '-' with no value)
+      content = ctx.namespace.toElement('');
+      content.classes.push('yaml-e-node');
+      content.classes.push('yaml-e-scalar');
+      if (ctx.sourceMap) {
+        content.startPositionRow = endRow;
+        content.startPositionColumn = endCol;
+        content.startIndex = endIdx;
+        content.endPositionRow = endRow;
+        content.endPositionColumn = endCol;
+        content.endIndex = endIdx;
+      }
+    }
+    return content;
+  },
+  walkBlockFlowNode: (cursor, ctx) => {
+    let content = null;
+    forEachNamedChild(cursor, ctx, child => {
+      const {
+        nodeType
+      } = child;
+      if (nodeType === 'tag' || nodeType === 'anchor' || nodeType === 'alias') {
+        throw new FallbackNeeded();
+      }
+      if (nodeType === 'comment') return;
+      const result = walkFunctions.walkNode(child, ctx);
+      if (result !== null && content === null) {
+        content = result;
+      }
+    });
+    return content;
+  },
+  walkPlainScalar: (cursor, ctx) => {
+    const formatted = formatFlowPlain(cursor.nodeText);
+    const element = ctx.namespace.toElement(resolveScalarContent(formatted));
+    if (ctx.sourceMap) setSourceMap(element, cursor);
+    if (formatted === '') {
+      element.classes.push('yaml-e-node');
+      element.classes.push('yaml-e-scalar');
+    }
+    return element;
+  },
+  walkSingleQuoteScalar: (cursor, ctx) => {
+    const formatted = formatFlowSingleQuoted(cursor.nodeText);
+    const element = ctx.namespace.toElement(formatted);
+    if (ctx.sourceMap) setSourceMap(element, cursor);
+    return element;
+  },
+  walkDoubleQuoteScalar: (cursor, ctx) => {
+    const formatted = formatFlowDoubleQuoted(cursor.nodeText);
+    const element = ctx.namespace.toElement(formatted);
+    if (ctx.sourceMap) setSourceMap(element, cursor);
+    return element;
+  },
+  walkBlockScalar: (cursor, ctx) => {
+    const raw = cursor.nodeText;
+    const formatted = raw.trimStart().startsWith('>') ? formatBlockFolded(raw) : formatBlockLiteral(raw);
+    const element = ctx.namespace.toElement(formatted);
+    if (ctx.sourceMap) setSourceMap(element, cursor);
+    return element;
+  },
+  walkError: (cursor, ctx) => {
+    const isUnexpected = !cursor.currentNode.hasError;
+    const message = isUnexpected ? '(Unexpected YAML syntax error)' : '(Error YAML syntax error)';
+    const ann = new AnnotationElement(message);
+    ann.classes.push('error');
+    if (ctx.sourceMap) setSourceMap(ann, cursor);
+    ctx.annotations.push(ann);
+    return null;
+  },
+  walkNode: (cursor, ctx) => {
+    switch (cursor.nodeType) {
+      case 'block_mapping':
+      case 'flow_mapping':
+        return walkFunctions.walkMapping(cursor, ctx);
+      case 'block_sequence':
+      case 'flow_sequence':
+        return walkFunctions.walkSequence(cursor, ctx);
+      case 'block_mapping_pair':
+      case 'flow_pair':
+        return walkFunctions.walkPair(cursor, ctx);
+      case 'block_sequence_item':
+        return walkFunctions.walkSequenceItem(cursor, ctx);
+      case 'block_node':
+      case 'flow_node':
+        return walkFunctions.walkBlockFlowNode(cursor, ctx);
+      case 'plain_scalar':
+        return walkFunctions.walkPlainScalar(cursor, ctx);
+      case 'single_quote_scalar':
+        return walkFunctions.walkSingleQuoteScalar(cursor, ctx);
+      case 'double_quote_scalar':
+        return walkFunctions.walkDoubleQuoteScalar(cursor, ctx);
+      case 'block_scalar':
+        return walkFunctions.walkBlockScalar(cursor, ctx);
+      case 'tag':
+      case 'anchor':
+      case 'alias':
+        throw new FallbackNeeded();
+      case 'ERROR':
+        return walkFunctions.walkError(cursor, ctx);
+      default:
+        return null;
+    }
+  }
+};
+
+/**
+ * Direct cursor-based syntactic analysis.
+ * Walks the tree-sitter CST once and builds ApiDOM elements directly,
+ * eliminating both the TreeCursorSyntaxNode pre-materialization and the
+ * intermediate YAML AST passes used by the indirect analysis.
+ *
+ * Throws FallbackNeeded when the document uses YAML tags, anchors, or aliases,
+ * which require the full two-pass indirect analysis to resolve correctly.
+ * @public
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const cursor = cst.walk();
+  const ctx = {
+    sourceMap,
+    namespace: createNamespace(),
+    annotations: [],
+    documentCount: 0
+  };
+
+  // When tree-sitter can't parse the input at all, the root node is ERROR rather than stream.
+  // In that case return an empty ParseResultElement containing only the error annotation.
+  if (cursor.nodeType !== 'stream') {
+    const parseResult = new ParseResultElement();
+    if (ctx.sourceMap) setSourceMap(parseResult, cursor);
+    walkFunctions.walkError(cursor, ctx);
+    ctx.annotations.forEach(ann => parseResult.push(ann));
+    return parseResult;
+  }
+  return walkFunctions.walkStream(cursor, ctx);
+};
+export default analyze;

package/src/syntactic-analysis/index.cjs

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _index = _interopRequireWildcard(require("./direct/index.cjs"));
+var _index2 = _interopRequireDefault(require("./indirect/index.cjs"));
+/**
+ * Syntactic analysis dispatcher.
+ * Attempts the fast direct cursor-based analysis first.
+ * Falls back to the indirect two-pass analysis when the document uses
+ * YAML features (tags, anchors, aliases) that the direct path cannot handle.
+ * @public
+ */
+const analyze = (cst, options = {}) => {
+  try {
+    return (0, _index.default)(cst, options);
+  } catch (e) {
+    if (e instanceof _index.FallbackNeeded) {
+      return (0, _index2.default)(cst, options);
+    }
+    throw e;
+  }
+};
+var _default = exports.default = analyze;

package/src/syntactic-analysis/index.mjs

@@ -0,0 +1,20 @@
+import directAnalyze, { FallbackNeeded } from "./direct/index.mjs";
+import indirectAnalyze from "./indirect/index.mjs";
+/**
+ * Syntactic analysis dispatcher.
+ * Attempts the fast direct cursor-based analysis first.
+ * Falls back to the indirect two-pass analysis when the document uses
+ * YAML features (tags, anchors, aliases) that the direct path cannot handle.
+ * @public
+ */
+const analyze = (cst, options = {}) => {
+  try {
+    return directAnalyze(cst, options);
+  } catch (e) {
+    if (e instanceof FallbackNeeded) {
+      return indirectAnalyze(cst, options);
+    }
+    throw e;
+  }
+};
+export default analyze;

package/types/apidom-parser-adapter-yaml-1-2.d.ts

@@ -2,7 +2,7 @@ import { MediaTypes } from '@swagger-api/apidom-core';
 import { Namespace } from '@swagger-api/apidom-core';
 import { ParseResultElement } from '@swagger-api/apidom-core';
 import { Tree as Tree_2 } from 'web-tree-sitter';
-import { Tree as Tree_3 } from 'tree-sitter';
+import type { Tree as Tree_3 } from 'tree-sitter';
 
 /**
  * @public
@@ -47,13 +47,14 @@ export declare interface ParseFunctionOptions {
 }
 
 /**
- * This version of syntactic analysis does following transformations:
- *   `TreeSitter CST -> YAML AST -> ApiDOM`
- * Two traversals passes are needed to get from CST to ApiDOM.
+ * Syntactic analysis dispatcher.
+ * Attempts the fast direct cursor-based analysis first.
+ * Falls back to the indirect two-pass analysis when the document uses
+ * YAML features (tags, anchors, aliases) that the direct path cannot handle.
  * @public
  */
-export declare const syntacticAnalysis: (cst: Tree, { sourceMap }?: {
-    sourceMap?: boolean | undefined;
+export declare const syntacticAnalysis: (cst: Tree, options?: {
+    sourceMap?: boolean;
 }) => ParseResultElement;
 
 /**