@speclynx/apidom-parser-adapter-json 1.12.1

package/src/media-types.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.JSONMediaTypes = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+/**
+ * @public
+ */
+class JSONMediaTypes extends _apidomCore.MediaTypes {
+  latest() {
+    return this[0];
+  }
+}
+
+/**
+ * @public
+ */
+exports.JSONMediaTypes = JSONMediaTypes;
+const mediaTypes = new JSONMediaTypes('application/json');
+var _default = exports.default = mediaTypes;

package/src/media-types.mjs

@@ -0,0 +1,16 @@
+import { MediaTypes } from '@speclynx/apidom-core';
+
+/**
+ * @public
+ */
+export class JSONMediaTypes extends MediaTypes {
+  latest() {
+    return this[0];
+  }
+}
+
+/**
+ * @public
+ */
+const mediaTypes = new JSONMediaTypes('application/json');
+export default mediaTypes;

package/src/syntactic-analysis/TreeCursorIterator.cjs

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _TreeCursorSyntaxNode = _interopRequireDefault(require("./TreeCursorSyntaxNode.cjs"));
+class TreeCursorIterator {
+  cursor;
+  constructor(cursor) {
+    this.cursor = cursor;
+  }
+  document() {
+    return new _TreeCursorSyntaxNode.default(this.cursor);
+  }
+  object() {
+    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
+  }
+  array() {
+    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
+  }
+  pair() {
+    return new _TreeCursorSyntaxNode.default(this.cursor);
+  }
+  string() {
+    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
+  }
+  number() {
+    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
+  }
+  null() {
+    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
+  }
+  true() {
+    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
+  }
+  false() {
+    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
+  }
+  ERROR() {
+    return new _TreeCursorSyntaxNode.default(this.cursor).setHasError(this.cursor);
+  }
+  *[Symbol.iterator]() {
+    let node;
+    if (this.cursor.nodeType in this) {
+      // @ts-ignore
+      node = this[this.cursor.nodeType]();
+    } else {
+      node = new _TreeCursorSyntaxNode.default(this.cursor);
+    }
+    if (this.cursor.gotoFirstChild()) {
+      const [firstChild] = new TreeCursorIterator(this.cursor);
+      node.pushChildren(firstChild);
+      while (this.cursor.gotoNextSibling()) {
+        const firstChildSiblings = new TreeCursorIterator(this.cursor);
+        node.pushChildren(...firstChildSiblings);
+      }
+      this.cursor.gotoParent();
+    }
+    yield node;
+  }
+}
+var _default = exports.default = TreeCursorIterator;

package/src/syntactic-analysis/TreeCursorIterator.mjs

@@ -0,0 +1,57 @@
+import TreeCursorSyntaxNode from "./TreeCursorSyntaxNode.mjs";
+class TreeCursorIterator {
+  cursor;
+  constructor(cursor) {
+    this.cursor = cursor;
+  }
+  document() {
+    return new TreeCursorSyntaxNode(this.cursor);
+  }
+  object() {
+    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
+  }
+  array() {
+    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
+  }
+  pair() {
+    return new TreeCursorSyntaxNode(this.cursor);
+  }
+  string() {
+    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
+  }
+  number() {
+    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
+  }
+  null() {
+    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
+  }
+  true() {
+    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
+  }
+  false() {
+    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
+  }
+  ERROR() {
+    return new TreeCursorSyntaxNode(this.cursor).setHasError(this.cursor);
+  }
+  *[Symbol.iterator]() {
+    let node;
+    if (this.cursor.nodeType in this) {
+      // @ts-ignore
+      node = this[this.cursor.nodeType]();
+    } else {
+      node = new TreeCursorSyntaxNode(this.cursor);
+    }
+    if (this.cursor.gotoFirstChild()) {
+      const [firstChild] = new TreeCursorIterator(this.cursor);
+      node.pushChildren(firstChild);
+      while (this.cursor.gotoNextSibling()) {
+        const firstChildSiblings = new TreeCursorIterator(this.cursor);
+        node.pushChildren(...firstChildSiblings);
+      }
+      this.cursor.gotoParent();
+    }
+    yield node;
+  }
+}
+export default TreeCursorIterator;

package/src/syntactic-analysis/TreeCursorSyntaxNode.cjs

@@ -0,0 +1,51 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class TreeCursorSyntaxNode {
+  type;
+  startPosition;
+  endPosition;
+  startIndex;
+  endIndex;
+  text;
+  isNamed;
+  isMissing;
+  fieldName = null;
+  hasError = false;
+  children = [];
+  constructor(cursor) {
+    this.type = cursor.nodeType;
+    this.startPosition = cursor.startPosition;
+    this.endPosition = cursor.endPosition;
+    this.startIndex = cursor.startIndex;
+    this.endIndex = cursor.endIndex;
+    this.text = cursor.nodeText;
+    this.isNamed = cursor.nodeIsNamed;
+    this.isMissing = cursor.nodeIsMissing;
+  }
+  get keyNode() {
+    if (this.type === 'pair') {
+      return this.children.find(node => node.fieldName === 'key');
+    }
+    return undefined;
+  }
+  get valueNode() {
+    if (this.type === 'pair') {
+      return this.children.find(node => node.fieldName === 'value');
+    }
+    return undefined;
+  }
+  setFieldName(cursor) {
+    this.fieldName = cursor.currentFieldName;
+    return this;
+  }
+  setHasError(cursor) {
+    this.hasError = cursor.currentNode.hasError;
+    return this;
+  }
+  pushChildren(...children) {
+    this.children.push(...children);
+  }
+}
+var _default = exports.default = TreeCursorSyntaxNode;

package/src/syntactic-analysis/TreeCursorSyntaxNode.mjs

@@ -0,0 +1,47 @@
+class TreeCursorSyntaxNode {
+  type;
+  startPosition;
+  endPosition;
+  startIndex;
+  endIndex;
+  text;
+  isNamed;
+  isMissing;
+  fieldName = null;
+  hasError = false;
+  children = [];
+  constructor(cursor) {
+    this.type = cursor.nodeType;
+    this.startPosition = cursor.startPosition;
+    this.endPosition = cursor.endPosition;
+    this.startIndex = cursor.startIndex;
+    this.endIndex = cursor.endIndex;
+    this.text = cursor.nodeText;
+    this.isNamed = cursor.nodeIsNamed;
+    this.isMissing = cursor.nodeIsMissing;
+  }
+  get keyNode() {
+    if (this.type === 'pair') {
+      return this.children.find(node => node.fieldName === 'key');
+    }
+    return undefined;
+  }
+  get valueNode() {
+    if (this.type === 'pair') {
+      return this.children.find(node => node.fieldName === 'value');
+    }
+    return undefined;
+  }
+  setFieldName(cursor) {
+    this.fieldName = cursor.currentFieldName;
+    return this;
+  }
+  setHasError(cursor) {
+    this.hasError = cursor.currentNode.hasError;
+    return this;
+  }
+  pushChildren(...children) {
+    this.children.push(...children);
+  }
+}
+export default TreeCursorSyntaxNode;

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

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomAst = require("@speclynx/apidom-ast");
+var _apidomCore = require("@speclynx/apidom-core");
+var _CstVisitor = _interopRequireDefault(require("./visitors/CstVisitor.cjs"));
+var _TreeCursorIterator = _interopRequireDefault(require("../TreeCursorIterator.cjs"));
+const keyMap = {
+  document: ['children'],
+  object: ['children'],
+  array: ['children'],
+  string: ['children'],
+  property: ['children'],
+  key: ['children'],
+  error: ['children'],
+  ..._apidomCore.keyMap
+};
+const getNodeType = node => {
+  if ((0, _apidomCore.isParseResultElement)(node)) {
+    return 'ParseResultElement';
+  }
+  if ((0, _apidomCore.isElement)(node)) {
+    return (0, _apidomCore.getNodeType)(node);
+  }
+  return (0, _apidomAst.getNodeType)(node);
+};
+
+// @ts-ignore
+const isNode = element => (0, _apidomCore.isElement)(element) || (0, _apidomAst.isNode)(element);
+
+/**
+ * This version of syntactic analysis translates TreeSitter CTS
+ * directly into ApiDOM.
+ *
+ * Transient transformation of TreeSitter CST is performed
+ * using TreeSitter cursor. TreeSitter cursor is a stateful object
+ * that allows us to walk syntax tree containing large number of nodes
+ * with maximum efficiency. Using this transient CST transformation
+ * gives us double the performance when syntactically analyzing
+ * CST into ApiDOM.
+ *
+ * Single traversal pass is needed to get from CST to ApiDOM.
+ * @public
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const visitor = new _CstVisitor.default();
+  const cursor = cst.walk();
+  const iterator = new _TreeCursorIterator.default(cursor);
+  const [rootNode] = Array.from(iterator);
+  return (0, _apidomAst.visit)(rootNode, visitor, {
+    // @ts-ignore
+    keyMap,
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode,
+    state: {
+      sourceMap
+    }
+  });
+};
+var _default = exports.default = analyze;

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

@@ -0,0 +1,59 @@
+import { visit, getNodeType as getCSTNodeType, isNode as isCSTNode } from '@speclynx/apidom-ast';
+import { isElement, isParseResultElement, keyMap as keyMapApiDOM, getNodeType as getNodeTypeApiDOM } from '@speclynx/apidom-core';
+import CstVisitor from "./visitors/CstVisitor.mjs";
+import TreeCursorIterator from "../TreeCursorIterator.mjs";
+const keyMap = {
+  document: ['children'],
+  object: ['children'],
+  array: ['children'],
+  string: ['children'],
+  property: ['children'],
+  key: ['children'],
+  error: ['children'],
+  ...keyMapApiDOM
+};
+const getNodeType = node => {
+  if (isParseResultElement(node)) {
+    return 'ParseResultElement';
+  }
+  if (isElement(node)) {
+    return getNodeTypeApiDOM(node);
+  }
+  return getCSTNodeType(node);
+};
+
+// @ts-ignore
+const isNode = element => isElement(element) || isCSTNode(element);
+
+/**
+ * This version of syntactic analysis translates TreeSitter CTS
+ * directly into ApiDOM.
+ *
+ * Transient transformation of TreeSitter CST is performed
+ * using TreeSitter cursor. TreeSitter cursor is a stateful object
+ * that allows us to walk syntax tree containing large number of nodes
+ * with maximum efficiency. Using this transient CST transformation
+ * gives us double the performance when syntactically analyzing
+ * CST into ApiDOM.
+ *
+ * Single traversal pass is needed to get from CST to ApiDOM.
+ * @public
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const visitor = new CstVisitor();
+  const cursor = cst.walk();
+  const iterator = new TreeCursorIterator(cursor);
+  const [rootNode] = Array.from(iterator);
+  return visit(rootNode, visitor, {
+    // @ts-ignore
+    keyMap,
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode,
+    state: {
+      sourceMap
+    }
+  });
+};
+export default analyze;

package/src/syntactic-analysis/direct/visitors/CstVisitor.cjs

@@ -0,0 +1,163 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var _TreeCursorSyntaxNode = _interopRequireDefault(require("../../TreeCursorSyntaxNode.cjs"));
+class CstVisitor {
+  static toPosition(node) {
+    const start = new _apidomCore.ArrayElement([node.startPosition.row, node.startPosition.column, node.startIndex]);
+    const end = new _apidomCore.ArrayElement([node.endPosition.row, node.endPosition.column, node.endIndex]);
+    start.classes.push('position');
+    end.classes.push('position');
+    return [start, end];
+  }
+  sourceMap = false;
+  annotations;
+  ParseResultElement = {
+    leave: element => {
+      // mark first-non Annotation element as result
+      // @ts-ignore
+      const elements = element.findElements(_apidomCore.isPrimitiveElement);
+      if (elements.length > 0) {
+        const resultElement = elements[0];
+        resultElement.classes.push('result');
+      }
+
+      // provide annotations
+      this.annotations.forEach(annotationElement => {
+        element.push(annotationElement);
+      });
+      this.annotations = [];
+    }
+  };
+  constructor() {
+    this.annotations = [];
+  }
+  enter(node) {
+    // missing anonymous literals from CST transformed into AnnotationElements.
+    if (node instanceof _TreeCursorSyntaxNode.default && !node.isNamed && node.isMissing) {
+      // collect annotations from missing literals
+      const value = node.type || node.text;
+      const message = `(Missing ${value})`;
+      const element = new _apidomCore.AnnotationElement(message);
+      element.classes.push('warning');
+      this.maybeAddSourceMap(node, element);
+      this.annotations.push(element);
+    }
+    return null; // remove everything unrecognized
+  }
+  document(node) {
+    const element = new _apidomCore.ParseResultElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  object(node) {
+    const element = new _apidomCore.ObjectElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  array(node) {
+    const element = new _apidomCore.ArrayElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  pair(node) {
+    const element = new _apidomCore.MemberElement();
+    // @ts-ignore
+    element.content.key = node.keyNode;
+    // @ts-ignore
+    element.content.value = node.valueNode;
+    this.maybeAddSourceMap(node, element);
+
+    /**
+     * Process possible errors here that may be present in pair node children as we're using direct field access.
+     * There are usually 3 children here found: "key", ":", "value".
+     */
+    if (node.children.length > 3) {
+      node.children.filter(child => child.type === 'ERROR').forEach(errorNode => {
+        this.ERROR(errorNode, node, [], [node]);
+      });
+    }
+    return element;
+  }
+  string(node) {
+    let element;
+    try {
+      element = new _apidomCore.StringElement(JSON.parse(node.text));
+    } catch (error) {
+      element = new _apidomCore.StringElement(node.text);
+      if (error instanceof Error) {
+        element.setMetaProperty('jsonParse', {
+          isError: true,
+          errorType: error.name,
+          errorMessage: error.message
+        });
+      }
+    }
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  number(node) {
+    const element = new _apidomCore.NumberElement(Number(node.text));
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  null(node) {
+    const element = new _apidomCore.NullElement();
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  true(node) {
+    const element = new _apidomCore.BooleanElement(true);
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  false(node) {
+    const element = new _apidomCore.BooleanElement(false);
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  ERROR(node, key, parent, path) {
+    // collect errors as annotations
+    const isUnexpected = !node.hasError;
+    const value = node.text;
+    const message = isUnexpected ? `(Unexpected ${value})` : `(Error ${value})`;
+    const element = new _apidomCore.AnnotationElement(message);
+    element.classes.push('error');
+    this.maybeAddSourceMap(node, element);
+    if (path.length === 0) {
+      // no document to visit, only error is present in CST
+      const parseResultElement = new _apidomCore.ParseResultElement();
+      parseResultElement.push(element);
+      return parseResultElement;
+    }
+
+    // we have CST node for document
+    this.annotations.push(element);
+    return null;
+  }
+  maybeAddSourceMap(node, element) {
+    if (!this.sourceMap) {
+      return;
+    }
+    const sourceMap = new _apidomCore.SourceMapElement();
+    const position = CstVisitor.toPosition(node);
+    if (position !== null) {
+      const [start, end] = position;
+      sourceMap.push(start);
+      sourceMap.push(end);
+    }
+    // @ts-ignore
+    sourceMap.astNode = node;
+    element.meta.set('sourceMap', sourceMap);
+  }
+}
+var _default = exports.default = CstVisitor;

package/src/syntactic-analysis/direct/visitors/CstVisitor.mjs

@@ -0,0 +1,158 @@
+import { BooleanElement, NullElement, NumberElement, ParseResultElement, SourceMapElement, MemberElement, ObjectElement, ArrayElement, StringElement, AnnotationElement, isPrimitiveElement } from '@speclynx/apidom-core';
+import TreeCursorSyntaxNode from "../../TreeCursorSyntaxNode.mjs";
+class CstVisitor {
+  static toPosition(node) {
+    const start = new ArrayElement([node.startPosition.row, node.startPosition.column, node.startIndex]);
+    const end = new ArrayElement([node.endPosition.row, node.endPosition.column, node.endIndex]);
+    start.classes.push('position');
+    end.classes.push('position');
+    return [start, end];
+  }
+  sourceMap = false;
+  annotations;
+  ParseResultElement = {
+    leave: element => {
+      // mark first-non Annotation element as result
+      // @ts-ignore
+      const elements = element.findElements(isPrimitiveElement);
+      if (elements.length > 0) {
+        const resultElement = elements[0];
+        resultElement.classes.push('result');
+      }
+
+      // provide annotations
+      this.annotations.forEach(annotationElement => {
+        element.push(annotationElement);
+      });
+      this.annotations = [];
+    }
+  };
+  constructor() {
+    this.annotations = [];
+  }
+  enter(node) {
+    // missing anonymous literals from CST transformed into AnnotationElements.
+    if (node instanceof TreeCursorSyntaxNode && !node.isNamed && node.isMissing) {
+      // collect annotations from missing literals
+      const value = node.type || node.text;
+      const message = `(Missing ${value})`;
+      const element = new AnnotationElement(message);
+      element.classes.push('warning');
+      this.maybeAddSourceMap(node, element);
+      this.annotations.push(element);
+    }
+    return null; // remove everything unrecognized
+  }
+  document(node) {
+    const element = new ParseResultElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  object(node) {
+    const element = new ObjectElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  array(node) {
+    const element = new ArrayElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  pair(node) {
+    const element = new MemberElement();
+    // @ts-ignore
+    element.content.key = node.keyNode;
+    // @ts-ignore
+    element.content.value = node.valueNode;
+    this.maybeAddSourceMap(node, element);
+
+    /**
+     * Process possible errors here that may be present in pair node children as we're using direct field access.
+     * There are usually 3 children here found: "key", ":", "value".
+     */
+    if (node.children.length > 3) {
+      node.children.filter(child => child.type === 'ERROR').forEach(errorNode => {
+        this.ERROR(errorNode, node, [], [node]);
+      });
+    }
+    return element;
+  }
+  string(node) {
+    let element;
+    try {
+      element = new StringElement(JSON.parse(node.text));
+    } catch (error) {
+      element = new StringElement(node.text);
+      if (error instanceof Error) {
+        element.setMetaProperty('jsonParse', {
+          isError: true,
+          errorType: error.name,
+          errorMessage: error.message
+        });
+      }
+    }
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  number(node) {
+    const element = new NumberElement(Number(node.text));
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  null(node) {
+    const element = new NullElement();
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  true(node) {
+    const element = new BooleanElement(true);
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  false(node) {
+    const element = new BooleanElement(false);
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  ERROR(node, key, parent, path) {
+    // collect errors as annotations
+    const isUnexpected = !node.hasError;
+    const value = node.text;
+    const message = isUnexpected ? `(Unexpected ${value})` : `(Error ${value})`;
+    const element = new AnnotationElement(message);
+    element.classes.push('error');
+    this.maybeAddSourceMap(node, element);
+    if (path.length === 0) {
+      // no document to visit, only error is present in CST
+      const parseResultElement = new ParseResultElement();
+      parseResultElement.push(element);
+      return parseResultElement;
+    }
+
+    // we have CST node for document
+    this.annotations.push(element);
+    return null;
+  }
+  maybeAddSourceMap(node, element) {
+    if (!this.sourceMap) {
+      return;
+    }
+    const sourceMap = new SourceMapElement();
+    const position = CstVisitor.toPosition(node);
+    if (position !== null) {
+      const [start, end] = position;
+      sourceMap.push(start);
+      sourceMap.push(end);
+    }
+    // @ts-ignore
+    sourceMap.astNode = node;
+    element.meta.set('sourceMap', sourceMap);
+  }
+}
+export default CstVisitor;