@speclynx/apidom-parser-adapter-yaml-1-2 1.12.1 → 2.0.1

package/src/tree-sitter/syntactic-analysis/YamlAstTransformer.cjs

@@ -0,0 +1,271 @@
+"use strict";
+
+exports.__esModule = true;
+exports.transformYamlAstToApiDOM = exports.default = void 0;
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _YamlStyle = require("./ast/nodes/YamlStyle.cjs");
+// Transform context passed through transformation
+
+// Node with type property and flat position properties
+
+// Helper to add source map to element
+const maybeAddSourceMap = (node, element, ctx) => {
+  if (!ctx.sourceMap) {
+    return;
+  }
+  _apidomDatamodel.SourceMapElement.transfer(node, element);
+};
+
+// Transform a single node based on its type
+const transform = (node, ctx) => {
+  if (node === null || node === undefined) {
+    return null;
+  }
+  const typedNode = node;
+  const nodeType = typedNode.type;
+  switch (nodeType) {
+    case 'stream':
+      return transformStream(typedNode, ctx);
+    case 'document':
+      return transformDocument(typedNode, ctx);
+    case 'mapping':
+      return transformMapping(typedNode, ctx);
+    case 'keyValuePair':
+      return transformKeyValuePair(typedNode, ctx);
+    case 'sequence':
+      return transformSequence(typedNode, ctx);
+    case 'scalar':
+      return transformScalar(typedNode, ctx);
+    case 'comment':
+      return transformComment(typedNode, ctx);
+    case 'literal':
+      return transformLiteral(typedNode, ctx);
+    case 'error':
+      return transformError(typedNode, ctx);
+    default:
+      // Unknown node type - skip
+      return null;
+  }
+};
+
+// Transform children array and flatten results
+const transformChildren = (children, ctx) => {
+  const results = [];
+  for (const child of children) {
+    const result = transform(child, ctx);
+    if (result === null) {
+      continue;
+    }
+    if (Array.isArray(result)) {
+      results.push(...result);
+    } else {
+      results.push(result);
+    }
+  }
+  return results;
+};
+
+// Stream: Wraps transformed children in ParseResultElement
+const transformStream = (node, ctx) => {
+  const element = new _apidomDatamodel.ParseResultElement();
+
+  // Transform all children
+  const children = transformChildren(node.children || [], ctx);
+
+  // Flatten and set content
+  // @ts-ignore
+  element._content = children.flat(1);
+
+  // Mark first primitive element as result
+  // @ts-ignore
+  const elements = element.findElements(_apidomDatamodel.isPrimitiveElement);
+  if (elements.length > 0) {
+    const resultElement = elements[0];
+    resultElement.classes.push('result');
+  }
+
+  // Add collected annotations
+  ctx.annotations.forEach(annotationElement => {
+    element.push(annotationElement);
+  });
+  ctx.annotations = [];
+  return element;
+};
+
+// Document: Returns transformed children for first doc, warns for subsequent docs
+const transformDocument = (node, ctx) => {
+  const shouldWarnAboutMoreDocuments = ctx.processedDocumentCount === 1;
+  const shouldSkipVisitingMoreDocuments = ctx.processedDocumentCount >= 1;
+  if (shouldWarnAboutMoreDocuments) {
+    const message = 'Only first document within YAML stream will be used. Rest will be discarded.';
+    const element = new _apidomDatamodel.AnnotationElement(message);
+    element.classes.push('warning');
+    maybeAddSourceMap(node, element, ctx);
+    ctx.annotations.push(element);
+  }
+  if (shouldSkipVisitingMoreDocuments) {
+    return null;
+  }
+  ctx.processedDocumentCount += 1;
+
+  // Transform and return children
+  return transformChildren(node.children || [], ctx);
+};
+
+// Mapping: Transforms to ObjectElement
+const transformMapping = (node, ctx) => {
+  const element = new _apidomDatamodel.ObjectElement();
+  // @ts-ignore
+  element._content = transformChildren(node.children || [], ctx);
+  maybeAddSourceMap(node, element, ctx);
+  return element;
+};
+
+// KeyValuePair: Transforms to MemberElement
+const transformKeyValuePair = (node, ctx) => {
+  const element = new _apidomDatamodel.MemberElement();
+
+  // Transform key and value (these are dynamically defined properties)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const keyResult = transform(node.key, ctx);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const valueResult = transform(node.value, ctx);
+
+  // @ts-ignore
+  element.content.key = keyResult;
+  // @ts-ignore
+  element.content.value = valueResult;
+  maybeAddSourceMap(node, element, ctx);
+
+  // Process any errors in children
+  (node.children || []
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ).filter(child => child?.type === 'error')
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  .forEach(errorNode => {
+    transformErrorAsAnnotation(errorNode, ctx);
+  });
+  return element;
+};
+
+// Sequence: Transforms to ArrayElement
+const transformSequence = (node, ctx) => {
+  const element = new _apidomDatamodel.ArrayElement();
+  // @ts-ignore
+  element._content = transformChildren(node.children || [], ctx);
+  maybeAddSourceMap(node, element, ctx);
+  return element;
+};
+
+// Scalar: Converts to Element via namespace
+const transformScalar = (node, ctx) => {
+  const element = ctx.namespace.toElement(node.content);
+
+  // Translate style information about empty nodes
+  if (node.content === '' && node.style === _YamlStyle.YamlStyle.Plain) {
+    element.classes.push('yaml-e-node');
+    element.classes.push('yaml-e-scalar');
+  }
+  maybeAddSourceMap(node, element, ctx);
+  return element;
+};
+
+// Comment: Returns CommentElement for pre-document comments only
+const transformComment = (node, ctx) => {
+  const isStreamComment = ctx.processedDocumentCount === 0;
+
+  // Only interested in stream comments before the first document
+  if (isStreamComment) {
+    // @ts-ignore
+    const element = new _apidomDatamodel.CommentElement(node.content);
+    maybeAddSourceMap(node, element, ctx);
+    return element;
+  }
+  return null;
+};
+
+// Literal: Handles missing nodes (creates warning annotation)
+const transformLiteral = (node, ctx) => {
+  if (node.isMissing) {
+    const message = `(Missing ${node.value})`;
+    const element = new _apidomDatamodel.AnnotationElement(message);
+    element.classes.push('warning');
+    maybeAddSourceMap(node, element, ctx);
+    ctx.annotations.push(element);
+  }
+  return null;
+};
+
+// Error as annotation (used by keyValuePair)
+const transformErrorAsAnnotation = (node, ctx) => {
+  const message = node.isUnexpected ? '(Unexpected YAML syntax error)' : '(Error YAML syntax error)';
+  const element = new _apidomDatamodel.AnnotationElement(message);
+  element.classes.push('error');
+  maybeAddSourceMap(node, element, ctx);
+  ctx.annotations.push(element);
+};
+
+// Error: Creates error annotation (adds to annotations array)
+const transformError = (node, ctx) => {
+  const message = node.isUnexpected ? '(Unexpected YAML syntax error)' : '(Error YAML syntax error)';
+  const element = new _apidomDatamodel.AnnotationElement(message);
+  element.classes.push('error');
+  maybeAddSourceMap(node, element, ctx);
+  ctx.annotations.push(element);
+  return null;
+};
+
+// Error at root level: Creates ParseResultElement with error annotation
+const transformRootError = (node, ctx) => {
+  const message = node.isUnexpected ? '(Unexpected YAML syntax error)' : '(Error YAML syntax error)';
+  const element = new _apidomDatamodel.AnnotationElement(message);
+  element.classes.push('error');
+  maybeAddSourceMap(node, element, ctx);
+  const parseResultElement = new _apidomDatamodel.ParseResultElement();
+  parseResultElement.push(element);
+  return parseResultElement;
+};
+/**
+ * Transforms YAML AST to ApiDOM ParseResultElement.
+ * @public
+ */
+const transformYamlAstToApiDOM = (yamlAst, {
+  sourceMap = false
+} = {}) => {
+  const ctx = {
+    sourceMap,
+    namespace: new _apidomDatamodel.Namespace(),
+    annotations: [],
+    processedDocumentCount: 0
+  };
+  const rootNode = yamlAst.rootNode;
+
+  // Handle empty parse result
+  if (!rootNode) {
+    return new _apidomDatamodel.ParseResultElement();
+  }
+
+  // Handle root-level error (no valid stream, just an error node)
+  if (rootNode.type === 'error') {
+    return transformRootError(rootNode, ctx);
+  }
+  const result = transform(rootNode, ctx);
+
+  // Result should be a ParseResultElement from transformStream
+  if (result instanceof _apidomDatamodel.ParseResultElement) {
+    return result;
+  }
+
+  // Fallback: wrap in ParseResultElement
+  const parseResult = new _apidomDatamodel.ParseResultElement();
+  if (result !== null) {
+    if (Array.isArray(result)) {
+      result.forEach(el => parseResult.push(el));
+    } else {
+      parseResult.push(result);
+    }
+  }
+  return parseResult;
+};
+exports.transformYamlAstToApiDOM = transformYamlAstToApiDOM;
+var _default = exports.default = transformYamlAstToApiDOM;

package/src/tree-sitter/syntactic-analysis/YamlAstTransformer.mjs

@@ -0,0 +1,263 @@
+import { ParseResultElement, AnnotationElement, CommentElement, MemberElement, ObjectElement, ArrayElement, isPrimitiveElement, Namespace, SourceMapElement } from '@speclynx/apidom-datamodel';
+import { YamlStyle } from "./ast/nodes/YamlStyle.mjs"; // Transform context passed through transformation
+// Node with type property and flat position properties
+// Helper to add source map to element
+const maybeAddSourceMap = (node, element, ctx) => {
+  if (!ctx.sourceMap) {
+    return;
+  }
+  SourceMapElement.transfer(node, element);
+};
+
+// Transform a single node based on its type
+const transform = (node, ctx) => {
+  if (node === null || node === undefined) {
+    return null;
+  }
+  const typedNode = node;
+  const nodeType = typedNode.type;
+  switch (nodeType) {
+    case 'stream':
+      return transformStream(typedNode, ctx);
+    case 'document':
+      return transformDocument(typedNode, ctx);
+    case 'mapping':
+      return transformMapping(typedNode, ctx);
+    case 'keyValuePair':
+      return transformKeyValuePair(typedNode, ctx);
+    case 'sequence':
+      return transformSequence(typedNode, ctx);
+    case 'scalar':
+      return transformScalar(typedNode, ctx);
+    case 'comment':
+      return transformComment(typedNode, ctx);
+    case 'literal':
+      return transformLiteral(typedNode, ctx);
+    case 'error':
+      return transformError(typedNode, ctx);
+    default:
+      // Unknown node type - skip
+      return null;
+  }
+};
+
+// Transform children array and flatten results
+const transformChildren = (children, ctx) => {
+  const results = [];
+  for (const child of children) {
+    const result = transform(child, ctx);
+    if (result === null) {
+      continue;
+    }
+    if (Array.isArray(result)) {
+      results.push(...result);
+    } else {
+      results.push(result);
+    }
+  }
+  return results;
+};
+
+// Stream: Wraps transformed children in ParseResultElement
+const transformStream = (node, ctx) => {
+  const element = new ParseResultElement();
+
+  // Transform all children
+  const children = transformChildren(node.children || [], ctx);
+
+  // Flatten and set content
+  // @ts-ignore
+  element._content = children.flat(1);
+
+  // Mark first primitive element as result
+  // @ts-ignore
+  const elements = element.findElements(isPrimitiveElement);
+  if (elements.length > 0) {
+    const resultElement = elements[0];
+    resultElement.classes.push('result');
+  }
+
+  // Add collected annotations
+  ctx.annotations.forEach(annotationElement => {
+    element.push(annotationElement);
+  });
+  ctx.annotations = [];
+  return element;
+};
+
+// Document: Returns transformed children for first doc, warns for subsequent docs
+const transformDocument = (node, ctx) => {
+  const shouldWarnAboutMoreDocuments = ctx.processedDocumentCount === 1;
+  const shouldSkipVisitingMoreDocuments = ctx.processedDocumentCount >= 1;
+  if (shouldWarnAboutMoreDocuments) {
+    const message = 'Only first document within YAML stream will be used. Rest will be discarded.';
+    const element = new AnnotationElement(message);
+    element.classes.push('warning');
+    maybeAddSourceMap(node, element, ctx);
+    ctx.annotations.push(element);
+  }
+  if (shouldSkipVisitingMoreDocuments) {
+    return null;
+  }
+  ctx.processedDocumentCount += 1;
+
+  // Transform and return children
+  return transformChildren(node.children || [], ctx);
+};
+
+// Mapping: Transforms to ObjectElement
+const transformMapping = (node, ctx) => {
+  const element = new ObjectElement();
+  // @ts-ignore
+  element._content = transformChildren(node.children || [], ctx);
+  maybeAddSourceMap(node, element, ctx);
+  return element;
+};
+
+// KeyValuePair: Transforms to MemberElement
+const transformKeyValuePair = (node, ctx) => {
+  const element = new MemberElement();
+
+  // Transform key and value (these are dynamically defined properties)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const keyResult = transform(node.key, ctx);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const valueResult = transform(node.value, ctx);
+
+  // @ts-ignore
+  element.content.key = keyResult;
+  // @ts-ignore
+  element.content.value = valueResult;
+  maybeAddSourceMap(node, element, ctx);
+
+  // Process any errors in children
+  (node.children || []
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ).filter(child => child?.type === 'error')
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  .forEach(errorNode => {
+    transformErrorAsAnnotation(errorNode, ctx);
+  });
+  return element;
+};
+
+// Sequence: Transforms to ArrayElement
+const transformSequence = (node, ctx) => {
+  const element = new ArrayElement();
+  // @ts-ignore
+  element._content = transformChildren(node.children || [], ctx);
+  maybeAddSourceMap(node, element, ctx);
+  return element;
+};
+
+// Scalar: Converts to Element via namespace
+const transformScalar = (node, ctx) => {
+  const element = ctx.namespace.toElement(node.content);
+
+  // Translate style information about empty nodes
+  if (node.content === '' && node.style === YamlStyle.Plain) {
+    element.classes.push('yaml-e-node');
+    element.classes.push('yaml-e-scalar');
+  }
+  maybeAddSourceMap(node, element, ctx);
+  return element;
+};
+
+// Comment: Returns CommentElement for pre-document comments only
+const transformComment = (node, ctx) => {
+  const isStreamComment = ctx.processedDocumentCount === 0;
+
+  // Only interested in stream comments before the first document
+  if (isStreamComment) {
+    // @ts-ignore
+    const element = new CommentElement(node.content);
+    maybeAddSourceMap(node, element, ctx);
+    return element;
+  }
+  return null;
+};
+
+// Literal: Handles missing nodes (creates warning annotation)
+const transformLiteral = (node, ctx) => {
+  if (node.isMissing) {
+    const message = `(Missing ${node.value})`;
+    const element = new AnnotationElement(message);
+    element.classes.push('warning');
+    maybeAddSourceMap(node, element, ctx);
+    ctx.annotations.push(element);
+  }
+  return null;
+};
+
+// Error as annotation (used by keyValuePair)
+const transformErrorAsAnnotation = (node, ctx) => {
+  const message = node.isUnexpected ? '(Unexpected YAML syntax error)' : '(Error YAML syntax error)';
+  const element = new AnnotationElement(message);
+  element.classes.push('error');
+  maybeAddSourceMap(node, element, ctx);
+  ctx.annotations.push(element);
+};
+
+// Error: Creates error annotation (adds to annotations array)
+const transformError = (node, ctx) => {
+  const message = node.isUnexpected ? '(Unexpected YAML syntax error)' : '(Error YAML syntax error)';
+  const element = new AnnotationElement(message);
+  element.classes.push('error');
+  maybeAddSourceMap(node, element, ctx);
+  ctx.annotations.push(element);
+  return null;
+};
+
+// Error at root level: Creates ParseResultElement with error annotation
+const transformRootError = (node, ctx) => {
+  const message = node.isUnexpected ? '(Unexpected YAML syntax error)' : '(Error YAML syntax error)';
+  const element = new AnnotationElement(message);
+  element.classes.push('error');
+  maybeAddSourceMap(node, element, ctx);
+  const parseResultElement = new ParseResultElement();
+  parseResultElement.push(element);
+  return parseResultElement;
+};
+/**
+ * Transforms YAML AST to ApiDOM ParseResultElement.
+ * @public
+ */
+export const transformYamlAstToApiDOM = (yamlAst, {
+  sourceMap = false
+} = {}) => {
+  const ctx = {
+    sourceMap,
+    namespace: new Namespace(),
+    annotations: [],
+    processedDocumentCount: 0
+  };
+  const rootNode = yamlAst.rootNode;
+
+  // Handle empty parse result
+  if (!rootNode) {
+    return new ParseResultElement();
+  }
+
+  // Handle root-level error (no valid stream, just an error node)
+  if (rootNode.type === 'error') {
+    return transformRootError(rootNode, ctx);
+  }
+  const result = transform(rootNode, ctx);
+
+  // Result should be a ParseResultElement from transformStream
+  if (result instanceof ParseResultElement) {
+    return result;
+  }
+
+  // Fallback: wrap in ParseResultElement
+  const parseResult = new ParseResultElement();
+  if (result !== null) {
+    if (Array.isArray(result)) {
+      result.forEach(el => parseResult.push(el));
+    } else {
+      parseResult.push(result);
+    }
+  }
+  return parseResult;
+};
+export default transformYamlAstToApiDOM;

package/src/tree-sitter/syntactic-analysis/ast/Error.cjs

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _Node = _interopRequireDefault(require("./Node.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Error extends _Node.default {
+  static type = 'error';
+  value;
+  isUnexpected;
+  constructor({
+    value,
+    isUnexpected = false,
+    ...rest
+  } = {}) {
+    super({
+      ...rest
+    });
+    this.value = value;
+    this.isUnexpected = isUnexpected;
+  }
+}
+var _default = exports.default = Error;

package/src/tree-sitter/syntactic-analysis/ast/Error.mjs

@@ -0,0 +1,24 @@
+import Node from "./Node.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class Error extends Node {
+  static type = 'error';
+  value;
+  isUnexpected;
+  constructor({
+    value,
+    isUnexpected = false,
+    ...rest
+  } = {}) {
+    super({
+      ...rest
+    });
+    this.value = value;
+    this.isUnexpected = isUnexpected;
+  }
+}
+export default Error;

package/src/tree-sitter/syntactic-analysis/ast/Literal.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _Node = _interopRequireDefault(require("./Node.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Literal extends _Node.default {
+  static type = 'literal';
+  value;
+  constructor({
+    value,
+    ...rest
+  } = {}) {
+    super({
+      ...rest
+    });
+    this.value = value;
+  }
+}
+var _default = exports.default = Literal;

package/src/tree-sitter/syntactic-analysis/ast/Literal.mjs

@@ -0,0 +1,21 @@
+import Node from "./Node.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class Literal extends Node {
+  static type = 'literal';
+  value;
+  constructor({
+    value,
+    ...rest
+  } = {}) {
+    super({
+      ...rest
+    });
+    this.value = value;
+  }
+}
+export default Literal;

package/src/tree-sitter/syntactic-analysis/ast/Node.cjs

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Node {
+  static type = 'node';
+  type = 'node';
+  isMissing;
+  children;
+  startLine;
+  startCharacter;
+  startOffset;
+  endLine;
+  endCharacter;
+  endOffset;
+  constructor({
+    children = [],
+    startLine,
+    startCharacter,
+    startOffset,
+    endLine,
+    endCharacter,
+    endOffset,
+    isMissing = false
+  } = {}) {
+    this.type = this.constructor.type;
+    this.isMissing = isMissing;
+    this.children = children;
+    this.startLine = startLine;
+    this.startCharacter = startCharacter;
+    this.startOffset = startOffset;
+    this.endLine = endLine;
+    this.endCharacter = endCharacter;
+    this.endOffset = endOffset;
+  }
+
+  // creates shallow clone of node
+  clone() {
+    // 1. copy has same prototype as orig
+    const copy = Object.create(Object.getPrototypeOf(this));
+
+    // 2. copy has all of orig’s properties
+    Object.getOwnPropertyNames(this) // (1)
+    .forEach(propKey => {
+      // (2)
+      const descriptor = Object.getOwnPropertyDescriptor(this, propKey); // (3)
+      // @ts-ignore
+      Object.defineProperty(copy, propKey, descriptor); // (4)
+    });
+    return copy;
+  }
+}
+var _default = exports.default = Node;