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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swagger-api/apidom-parser-adapter-yaml-1-2",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "Parser adapter for parsing YAML documents into base namespace.",
   "publishConfig": {
     "access": "public",
@@ -51,9 +51,9 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@babel/runtime-corejs3": "^7.26.10",
-    "@swagger-api/apidom-ast": "^1.11.1",
-    "@swagger-api/apidom-core": "^1.11.1",
-    "@swagger-api/apidom-error": "^1.11.1",
+    "@swagger-api/apidom-ast": "^1.11.2",
+    "@swagger-api/apidom-core": "^1.11.2",
+    "@swagger-api/apidom-error": "^1.11.2",
     "@tree-sitter-grammars/tree-sitter-yaml": "=0.7.1",
     "@types/ramda": "~0.30.0",
     "ramda": "~0.30.0",
@@ -75,5 +75,5 @@
     "README.md",
     "CHANGELOG.md"
   ],
-  "gitHead": "d5eeb79d3efa930929dc9b3378b36071be8ed44d"
+  "gitHead": "0ace20a29a3ed690af50b47734114fe06219dc20"
 }

package/src/adapter-browser.cjs

@@ -5,7 +5,7 @@ exports.__esModule = true;
 exports.parse = exports.namespace = exports.mediaTypes = exports.detect = void 0;
 var _browser = _interopRequireDefault(require("./lexical-analysis/browser.cjs"));
 exports.lexicalAnalysis = _browser.default;
-var _index = _interopRequireDefault(require("./syntactic-analysis/indirect/index.cjs"));
+var _index = _interopRequireDefault(require("./syntactic-analysis/index.cjs"));
 exports.syntacticAnalysis = _index.default;
 var _adapter = require("./adapter.cjs");
 exports.mediaTypes = _adapter.mediaTypes;

package/src/adapter-browser.mjs

@@ -1,5 +1,5 @@
 import lexicalAnalysis from "./lexical-analysis/browser.mjs";
-import syntacticAnalysis from "./syntactic-analysis/indirect/index.mjs";
+import syntacticAnalysis from "./syntactic-analysis/index.mjs";
 export { mediaTypes, namespace } from "./adapter.mjs";
 export { lexicalAnalysis, syntacticAnalysis };
 

package/src/adapter-node.cjs

@@ -5,7 +5,7 @@ exports.__esModule = true;
 exports.parse = exports.namespace = exports.mediaTypes = exports.detect = void 0;
 var _node = _interopRequireDefault(require("./lexical-analysis/node.cjs"));
 exports.lexicalAnalysis = _node.default;
-var _index = _interopRequireDefault(require("./syntactic-analysis/indirect/index.cjs"));
+var _index = _interopRequireDefault(require("./syntactic-analysis/index.cjs"));
 exports.syntacticAnalysis = _index.default;
 var _adapter = require("./adapter.cjs");
 exports.mediaTypes = _adapter.mediaTypes;

package/src/adapter-node.mjs

@@ -1,5 +1,5 @@
 import lexicalAnalysis from "./lexical-analysis/node.mjs";
-import syntacticAnalysis from "./syntactic-analysis/indirect/index.mjs";
+import syntacticAnalysis from "./syntactic-analysis/index.mjs";
 export { mediaTypes, namespace } from "./adapter.mjs";
 export { lexicalAnalysis, syntacticAnalysis };
 

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

@@ -0,0 +1,389 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.FallbackNeeded = void 0;
+var _apidomCore = require("@swagger-api/apidom-core");
+var _apidomAst = require("@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
+ */
+class FallbackNeeded extends Error {
+  name = 'FallbackNeeded';
+}
+
+// YAML 1.2 Core Schema type detection — matches apidom-ast/yaml/schemas/json/* order:
+// Null → Integer → FloatingPoint → Boolean
+exports.FallbackNeeded = FallbackNeeded;
+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 _apidomCore.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 : null);
+    }
+  } while (cursor.gotoNextSibling());
+  cursor.gotoParent();
+};
+const walkFunctions = {
+  walkStream: (cursor, ctx) => {
+    const parseResult = new _apidomCore.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 _apidomCore.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(_apidomCore.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 _apidomCore.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 _apidomCore.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 _apidomCore.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 _apidomCore.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 = (0, _apidomAst.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 = (0, _apidomAst.formatFlowSingleQuoted)(cursor.nodeText);
+    const element = ctx.namespace.toElement(formatted);
+    if (ctx.sourceMap) setSourceMap(element, cursor);
+    return element;
+  },
+  walkDoubleQuoteScalar: (cursor, ctx) => {
+    const formatted = (0, _apidomAst.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('>') ? (0, _apidomAst.formatBlockFolded)(raw) : (0, _apidomAst.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 _apidomCore.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: (0, _apidomCore.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 _apidomCore.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);
+};
+var _default = exports.default = analyze;