@swagger-api/apidom-parser-adapter-json 0.68.1

package/es/syntactic-analysis/PreOrderCursorChildrenIterator.js

@@ -0,0 +1,32 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+let _Symbol$iterator;
+_Symbol$iterator = Symbol.iterator;
+class PreOrderCursorChildrenIterator {
+  constructor(cursor) {
+    _defineProperty(this, "cursor", void 0);
+    this.cursor = cursor;
+  }
+  createNode() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      children: []
+    };
+  }
+  *[_Symbol$iterator]() {
+    // @ts-ignore
+    const method = this[this.cursor.nodeType];
+    const currentNode = (method || this.createNode).call(this);
+    const constructor = this.constructor;
+    if (this.cursor.gotoFirstChild()) {
+      currentNode.children.push(...[...new constructor(this.cursor)]);
+      while (this.cursor.gotoNextSibling()) {
+        currentNode.children.push(...[...new constructor(this.cursor)]);
+      }
+      this.cursor.gotoParent();
+    }
+    yield currentNode;
+  }
+}
+export default PreOrderCursorChildrenIterator;

package/es/syntactic-analysis/PreOrderCusrorIterator.js

@@ -0,0 +1,30 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+let _Symbol$iterator;
+_Symbol$iterator = Symbol.iterator;
+class PreOrderCursorIterator {
+  constructor(cursor) {
+    _defineProperty(this, "cursor", void 0);
+    this.cursor = cursor;
+  }
+  createNode() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition
+    };
+  }
+  *[_Symbol$iterator]() {
+    // @ts-ignore
+    const method = this[this.cursor.nodeType];
+    const constructor = this.constructor;
+    yield (method || this.createNode).call(this);
+    if (this.cursor.gotoFirstChild()) {
+      yield* new constructor(this.cursor);
+      while (this.cursor.gotoNextSibling()) {
+        yield* new constructor(this.cursor);
+      }
+      this.cursor.gotoParent();
+    }
+  }
+}
+export default PreOrderCursorIterator;

package/es/syntactic-analysis/direct/CursorIterator.js

@@ -0,0 +1,104 @@
+import PreOrderCursorChildrenIterator from "../PreOrderCursorChildrenIterator.js";
+class CursorIterator extends PreOrderCursorChildrenIterator {
+  document() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      children: []
+    };
+  }
+  object() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      fieldName: this.cursor.currentFieldName,
+      children: []
+    };
+  }
+  array() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      fieldName: this.cursor.currentFieldName,
+      children: []
+    };
+  }
+  pair() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      get keyNode() {
+        return this.children.find(node => node.fieldName === 'key');
+      },
+      get valueNode() {
+        return this.children.find(node => node.fieldName === 'value');
+      },
+      children: []
+    };
+  }
+  string() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      text: this.cursor.nodeText,
+      fieldName: this.cursor.currentFieldName,
+      children: []
+    };
+  }
+  number() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      text: this.cursor.nodeText,
+      fieldName: this.cursor.currentFieldName,
+      children: []
+    };
+  }
+  null() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      fieldName: this.cursor.currentFieldName,
+      children: []
+    };
+  }
+  true() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      fieldName: this.cursor.currentFieldName,
+      children: []
+    };
+  }
+  false() {
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      fieldName: this.cursor.currentFieldName,
+      children: []
+    };
+  }
+  ERROR() {
+    const {
+      currentNode
+    } = this.cursor;
+    return {
+      type: this.cursor.nodeType,
+      startPosition: this.cursor.startPosition,
+      endPosition: this.cursor.endPosition,
+      // @ts-ignore
+      hasError: () => currentNode.hasError(),
+      children: []
+    };
+  }
+}
+export default CursorIterator;

package/es/syntactic-analysis/direct/index.js

@@ -0,0 +1,227 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import stampit from 'stampit';
+import { visit, getNodeType as getCSTNodeType, isNode as isCSTNode } from '@swagger-api/apidom-ast';
+import { BooleanElement, NullElement, NumberElement, ParseResultElement, SourceMapElement, MemberElement, ObjectElement, ArrayElement, StringElement, AnnotationElement, isElement, isParseResultElement, isPrimitiveElement, keyMap as keyMapApiDOM, getNodeType as getNodeTypeApiDOM } from '@swagger-api/apidom-core';
+
+/* eslint-disable no-underscore-dangle */
+
+const keyMap = _objectSpread({
+  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);
+const Visitor = stampit({
+  props: {
+    sourceMap: false,
+    annotations: []
+  },
+  init() {
+    /**
+     * Private API.
+     */
+
+    this.annotations = [];
+    const toPosition = node => {
+      if (node === null) {
+        return null;
+      }
+      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];
+    };
+    const maybeAddSourceMap = (node, element) => {
+      if (!this.sourceMap) {
+        return;
+      }
+      const sourceMap = new SourceMapElement();
+      const position = 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);
+    };
+    const getFieldFromNode = (fieldName, node) => {
+      var _node$childForFieldNa;
+      return `${fieldName}Node` in node ?
+      // @ts-ignore
+      node[`${fieldName}Node`] : 'childForFieldName' in node ? (_node$childForFieldNa = node.childForFieldName) === null || _node$childForFieldNa === void 0 ? void 0 : _node$childForFieldNa.call(node, fieldName) : null;
+    };
+
+    /**
+     * Public API.
+     */
+
+    this.enter = function enter(node) {
+      // missing anonymous literals from CST transformed into AnnotationElements.
+      // WARNING: be aware that web-tree-sitter and tree-sitter node bindings have inconsistency
+      // in `SyntaxNode.isNamed` property. web-tree-sitter has it defined as method
+      // whether tree-sitter node binding has it defined as a boolean property.
+      if ((typeof node.isNamed === 'function' && !node.isNamed() || node.isNamed === false) && 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');
+        maybeAddSourceMap(node, element);
+        this.annotations.push(element);
+      }
+      return null; // remove everything unrecognized
+    };
+
+    this.document = function document(node) {
+      const element = new ParseResultElement();
+      // @ts-ignore
+      element._content = node.children;
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.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 = [];
+      }
+    };
+    this.object = function object(node) {
+      const element = new ObjectElement();
+      // @ts-ignore
+      element._content = node.children;
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.array = function array(node) {
+      const element = new ArrayElement();
+      // @ts-ignore
+      element._content = node.children;
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.pair = function pair(node) {
+      const element = new MemberElement();
+      // @ts-ignore
+      element.content.key = getFieldFromNode('key', node);
+      // @ts-ignore
+      element.content.value = getFieldFromNode('value', node);
+      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
+        // @ts-ignore
+        .filter(child => child.type === 'ERROR').forEach(errorNode => {
+          this.ERROR(errorNode, node, [], [node]);
+        });
+      }
+      return element;
+    };
+    this.string = function string(node) {
+      const element = new StringElement(node.text.slice(1, -1));
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.number = function number(node) {
+      const element = new NumberElement(Number(node.text));
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.null = function _null(node) {
+      const element = new NullElement();
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.true = function _true(node) {
+      const element = new BooleanElement(true);
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.false = function _false(node) {
+      const element = new BooleanElement(false);
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.ERROR = function 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');
+      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;
+    };
+  }
+});
+
+/**
+ * This version of syntactic analysis translates TreeSitter CTS into ApiDOM.
+ * Single traversal pass is needed to get from CST to ApiDOM.
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const visitor = Visitor();
+  return visit(cst.rootNode, visitor, {
+    // @ts-ignore
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter: getNodeType,
+    // @ts-ignore
+    nodePredicate: isNode,
+    state: {
+      sourceMap
+    }
+  });
+};
+export default analyze;

package/es/syntactic-analysis/indirect/index.js

@@ -0,0 +1,34 @@
+import { visit } from '@swagger-api/apidom-ast';
+import CstVisitor, { keyMap as cstKeyMap } from "./visitors/CstVisitor.js";
+import JsonAstVisitor, { keyMap as astKeyMap, isNode, getNodeType } from "./visitors/JsonAstVisitor.js";
+/**
+ * This version of syntactic analysis does following transformations:
+ *   TreeSitter CST -> JSON AST -> ApiDOM
+ * Two traversals passes are needed to get from CST to ApiDOM.
+ * This analysis is much slower than the direct one, but allows
+ * to do additional analysis magic on JSON AST.
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const cstVisitor = CstVisitor();
+  const astVisitor = JsonAstVisitor();
+  const jsonAst = visit(cst.rootNode, cstVisitor, {
+    // @ts-ignore
+    keyMap: cstKeyMap,
+    state: {
+      sourceMap
+    }
+  });
+  return visit(jsonAst.rootNode, astVisitor, {
+    // @ts-ignore
+    keyMap: astKeyMap,
+    // @ts-ignore
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode,
+    state: {
+      sourceMap
+    }
+  });
+};
+export default analyze;

package/es/syntactic-analysis/indirect/visitors/CstVisitor.js

@@ -0,0 +1,183 @@
+import stampit from 'stampit';
+import { JsonArray, JsonDocument, JsonFalse, JsonNull, JsonNumber, JsonObject, JsonKey, JsonProperty, JsonString, JsonStringContent, JsonTrue, ParseResult, Position, Point, Literal, Error } from '@swagger-api/apidom-ast';
+export const keyMap = {
+  document: ['children'],
+  object: ['children'],
+  array: ['children'],
+  string: ['children'],
+  property: ['children'],
+  key: ['children'],
+  error: ['children']
+};
+const CstVisitor = stampit({
+  init() {
+    /**
+     * Private API.
+     */
+
+    const toPosition = node => {
+      if (node === null) {
+        return null;
+      }
+      const start = Point({
+        row: node.startPosition.row,
+        column: node.startPosition.column,
+        char: node.startIndex
+      });
+      const end = Point({
+        row: node.endPosition.row,
+        column: node.endPosition.column,
+        char: node.endIndex
+      });
+      return Position({
+        start,
+        end
+      });
+    };
+    const getFieldFromNode = (fieldName, node) => {
+      var _node$childForFieldNa;
+      return `${fieldName}Node` in node ?
+      // @ts-ignore
+      node[`${fieldName}Node`] : 'childForFieldName' in node ? (_node$childForFieldNa = node.childForFieldName) === null || _node$childForFieldNa === void 0 ? void 0 : _node$childForFieldNa.call(node, fieldName) : null;
+    };
+
+    /**
+     * Public API.
+     */
+
+    this.enter = function enter(node) {
+      // missing anonymous literals from CST transformed into AST literal nodes
+      // WARNING: be aware that web-tree-sitter and tree-sitter node bindings have inconsistency
+      // in `SyntaxNode.isNamed` property. web-tree-sitter has it defined as method
+      // whether tree-sitter node binding has it defined as a boolean property.
+      // @ts-ignore
+      if (typeof node.isNamed === 'function' && !node.isNamed() || node.isNamed === false) {
+        const position = toPosition(node);
+        const value = node.type || node.text;
+        const isMissing = node.isMissing();
+        return Literal({
+          value,
+          position,
+          isMissing
+        });
+      }
+      return undefined;
+    };
+    this.document = {
+      enter(node) {
+        const position = toPosition(node);
+        return JsonDocument({
+          children: node.children,
+          position,
+          isMissing: node.isMissing()
+        });
+      },
+      leave(document) {
+        return ParseResult({
+          children: [document]
+        });
+      }
+    };
+    this.object = function object(node) {
+      const position = toPosition(node);
+      return JsonObject({
+        children: node.children,
+        position,
+        isMissing: node.isMissing()
+      });
+    };
+    this.pair = function pair(node) {
+      const position = toPosition(node);
+      const children = node.children.slice(1);
+      const keyNode = getFieldFromNode('key', node);
+      const key = JsonKey({
+        children: (keyNode === null || keyNode === void 0 ? void 0 : keyNode.children) || [],
+        position: toPosition(keyNode),
+        isMissing: (keyNode === null || keyNode === void 0 ? void 0 : keyNode.isMissing()) || false
+      });
+      return JsonProperty({
+        children: [key, ...children],
+        position,
+        isMissing: node.isMissing()
+      });
+    };
+    this.array = function array(node) {
+      const position = toPosition(node);
+      return JsonArray({
+        children: node.children,
+        position,
+        isMissing: node.isMissing()
+      });
+    };
+    this.string = function string(node) {
+      const position = toPosition(node);
+      const content = JsonStringContent({
+        value: node.text.slice(1, -1)
+      });
+      return JsonString({
+        children: [content],
+        position,
+        isMissing: node.isMissing()
+      });
+    };
+    this.number = function number(node) {
+      const position = toPosition(node);
+      const value = node.text;
+      return JsonNumber({
+        value,
+        position,
+        isMissing: node.isMissing()
+      });
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.null = function _null(node) {
+      const position = toPosition(node);
+      const value = node.text;
+      return JsonNull({
+        value,
+        position,
+        isMissing: node.isMissing()
+      });
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.true = function _true(node) {
+      const position = toPosition(node);
+      const value = node.text;
+      return JsonTrue({
+        value,
+        position,
+        isMissing: node.isMissing()
+      });
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.false = function _false(node) {
+      const position = toPosition(node);
+      const value = node.text;
+      return JsonFalse({
+        value,
+        position,
+        isMissing: node.isMissing()
+      });
+    };
+    this.ERROR = function ERROR(node, key, parent, path) {
+      const position = toPosition(node);
+      const errorNode = Error({
+        children: node.children,
+        position,
+        isUnexpected: !node.hasError(),
+        isMissing: node.isMissing(),
+        value: node.text
+      });
+      if (path.length === 0) {
+        return ParseResult({
+          children: [errorNode]
+        });
+      }
+      return errorNode;
+    };
+  }
+});
+export default CstVisitor;